Fix typeshed path

Author: Mikhail Arkhipov

src/Analysis/Ast/Impl/Analyzer/StubMerger.cs

@@ -149,6 +149,10 @@ private void TryReplaceMember(IVariable v, IPythonType sourceType, IPythonType s
                     MergeMembers(v, sourceFunction, stubType, cancellationToken);
                     break;
 
+                case PythonPropertyType sourceProperty:
+                    MergeMembers(v, sourceProperty, stubType, cancellationToken);
+                    break;
+
                 case IPythonModule _:
                     // We do not re-declare modules.
                     break;
@@ -203,7 +207,7 @@ private void MergeMembers(IVariable v, IPythonType sourceType, IPythonType stubT
                     continue; // Do not add unknowns to the stub.
                 }
                 var sourceMemberType = sourceMember?.GetPythonType();
-                if (sourceMemberType is IPythonClassMember cm && cm.DeclaringType != sourceType) {
+                if (sourceMemberType is IPythonClassMember cm && !cm.DeclaringModule.Equals(sourceType.DeclaringModule)) {
                     continue; // Only take members from this class and not from bases.
                 }
                 if (!IsFromThisModuleOrSubmodules(sourceMemberType)) {

src/Analysis/Ast/Impl/Modules/Resolution/TypeshedResolution.cs

@@ -32,8 +32,12 @@ internal sealed class TypeshedResolution : ModuleResolutionBase, IModuleResoluti
 
         public TypeshedResolution(string root, IServiceContainer services) : base(root, services) {
             // TODO: merge with user-provided stub paths
-            var stubs = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Stubs");
+            var asmLocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+            var stubs = Path.Combine(asmLocation, "Stubs");
+            var typeshed = Path.Combine(asmLocation, "Typeshed");
+            
             _typeStubPaths = GetTypeShedPaths(Root)
+                .Concat(GetTypeShedPaths(typeshed))
                 .Concat(GetTypeShedPaths(stubs))
                 .Where(services.GetService<IFileSystem>().DirectoryExists)
                 .ToImmutableArray();

src/LanguageServer/Impl/Implementation/Server.Editor.cs

@@ -89,17 +89,23 @@ public async Task<Reference[]> GotoDefinition(TextDocumentPositionParams @params
             _log?.Log(TraceEventType.Verbose, $"Goto Definition in {uri} at {@params.position}");
 
             var analysis = await Document.GetAnalysisAsync(uri, Services, CompletionAnalysisTimeout, cancellationToken);
-            var reference = new DefinitionSource(Services).FindDefinition(analysis, @params.position, out _);
-            return reference != null ? new[] { reference } : Array.Empty<Reference>();
+            var ds = new DefinitionSource(Services);
+            var reference = ds.FindDefinition(analysis, @params.position, out _);
+            return reference != null && ds.CanNavigateToModule(reference.uri) 
+                ? new[] { reference } 
+                : Array.Empty<Reference>();
         }
 
         public async Task<Location> GotoDeclaration(TextDocumentPositionParams @params, CancellationToken cancellationToken) {
             var uri = @params.textDocument.uri;
             _log?.Log(TraceEventType.Verbose, $"Goto Declaration in {uri} at {@params.position}");
 
             var analysis = await Document.GetAnalysisAsync(uri, Services, CompletionAnalysisTimeout, cancellationToken);
-            var reference = new DeclarationSource(Services).FindDefinition(analysis, @params.position, out _);
-            return reference != null ? new Location { uri = reference.uri, range = reference.range } : null;
+            var ds = new DeclarationSource(Services);
+            var reference = ds.FindDefinition(analysis, @params.position, out _);
+            return reference != null && ds.CanNavigateToModule(reference.uri) 
+                ? new Location { uri = reference.uri, range = reference.range } 
+                : null;
         }
 
         public Task<Reference[]> FindReferences(ReferencesParams @params, CancellationToken cancellationToken) {
@@ -137,8 +143,8 @@ public async Task<CodeAction[]> CodeAction(CodeActionParams @params, Cancellatio
 
             return codeActions.ToArray();
 
-            static bool AskedFor(CodeActionParams @params, string codeActionKind) {
-                return @params.context.only == null || @params.context.only.Any(s => s.StartsWith(codeActionKind));
+            bool AskedFor(CodeActionParams p, string codeActionKind) {
+                return p.context.only == null || p.context.only.Any(s => s.StartsWith(codeActionKind));
             }
         }
     }

src/LanguageServer/Impl/Sources/DefinitionSource.cs

@@ -14,6 +14,7 @@
 // permissions and limitations under the License.
 
 using System;
+using System.IO;
 using System.Linq;
 using Microsoft.Python.Analysis;
 using Microsoft.Python.Analysis.Analyzer;
@@ -360,22 +361,32 @@ private Reference FromMember(IMember m) {
             return null;
         }
 
-        private bool CanNavigateToModule(Uri uri) {
+        public bool CanNavigateToModule(Uri uri) {
             if (uri == null) {
                 return false;
             }
+
+            if (!CanNavigateToPath(uri.LocalPath)) {
+                return false;
+            }
             var rdt = _services.GetService<IRunningDocumentTable>();
             var doc = rdt.GetDocument(uri);
             //  Allow navigation to modules not in RDT - most probably
             // it is a module that was restored from database.
             return doc == null || CanNavigateToModule(doc);
         }
 
-        private static bool CanNavigateToModule(IPythonModule m)
-            => m?.ModuleType == ModuleType.User ||
-               m?.ModuleType == ModuleType.Stub ||
-               m?.ModuleType == ModuleType.Package ||
-               m?.ModuleType == ModuleType.Library ||
-               m?.ModuleType == ModuleType.Specialized;
+        private static bool CanNavigateToModule(IPythonModule m) {
+            if(m == null || !CanNavigateToPath(m.FilePath)) {
+                return false;
+            }
+            return m.ModuleType == ModuleType.User ||
+                m.ModuleType == ModuleType.Stub ||
+                m.ModuleType == ModuleType.Package ||
+                m.ModuleType == ModuleType.Library ||
+                m.ModuleType == ModuleType.Specialized;
+        }
+
+        private static bool CanNavigateToPath(string path) => Path.GetExtension(path) != ".exe";
     }
 }