@zzzen/pyright-internal 1.2.0-dev.20230924 → 1.2.0-dev.20231008

package/dist/languageService/documentSymbolCollector.d.ts

@@ -1,32 +1,44 @@
 import { CancellationToken } from 'vscode-languageserver';
 import { Declaration } from '../analyzer/declaration';
 import { ParseTreeWalker } from '../analyzer/parseTreeWalker';
-import { ProgramView } from '../common/extensibility';
+import { TypeEvaluator } from '../analyzer/typeEvaluatorTypes';
+import { ProgramView, ReferenceUseCase, SymbolUsageProvider } from '../common/extensibility';
 import { TextRange } from '../common/textRange';
 import { NameNode, ParseNode, StringListNode, StringNode } from '../parser/parseNodes';
 export declare type CollectionResult = {
     node: NameNode | StringNode;
     range: TextRange;
 };
-export declare enum DocumentSymbolCollectorUseCase {
-    Rename = 0,
-    Reference = 1
+export interface DocumentSymbolCollectorOptions {
+    readonly treatModuleInImportAndFromImportSame?: boolean;
+    readonly skipUnreachableCode?: boolean;
+    readonly useCase?: ReferenceUseCase;
+    /**
+     * If `providers` are set, `collector` will assume
+     * `appendSymbolNamesTo` and `appendDeclarationsTo` have already
+     * been handled and will not call them again.
+     *
+     * If `collector` will result in the same `providers`, `symbolNames`, and `decls` for
+     * all files, set `providers` so that `collector` doesn't need to perform the same work
+     * repeatedly for all files.
+     */
+    readonly providers?: readonly SymbolUsageProvider[];
 }
 export declare class DocumentSymbolCollector extends ParseTreeWalker {
-    private _program;
-    private _declarations;
-    private _cancellationToken;
-    private _startingNode;
-    private _treatModuleInImportAndFromImportSame;
-    private _skipUnreachableCode;
-    private _useCase;
-    private _results;
-    private _dunderAllNameNodes;
-    private _initFunction;
-    private _symbolNames;
-    constructor(_program: ProgramView, symbolNames: string[], _declarations: Declaration[], _cancellationToken: CancellationToken, _startingNode: ParseNode, _treatModuleInImportAndFromImportSame?: boolean, _skipUnreachableCode?: boolean, _useCase?: DocumentSymbolCollectorUseCase);
-    static collectFromNode(program: ProgramView, node: NameNode, cancellationToken: CancellationToken, startingNode?: ParseNode, treatModuleInImportAndFromImportSame?: boolean, skipUnreachableCode?: boolean, useCase?: DocumentSymbolCollectorUseCase): CollectionResult[];
-    static getDeclarationsForNode(program: ProgramView, node: NameNode, resolveLocalName: boolean, useCase: DocumentSymbolCollectorUseCase, token: CancellationToken): Declaration[];
+    private readonly _program;
+    private readonly _startingNode;
+    private readonly _cancellationToken;
+    private readonly _results;
+    private readonly _dunderAllNameNodes;
+    private readonly _symbolNames;
+    private readonly _declarations;
+    private readonly _usageProviders;
+    private readonly _treatModuleInImportAndFromImportSame;
+    private readonly _skipUnreachableCode;
+    private readonly _useCase;
+    constructor(_program: ProgramView, symbolNames: string[], declarations: Declaration[], _startingNode: ParseNode, _cancellationToken: CancellationToken, options?: DocumentSymbolCollectorOptions);
+    static collectFromNode(program: ProgramView, node: NameNode, cancellationToken: CancellationToken, startingNode?: ParseNode, options?: DocumentSymbolCollectorOptions): CollectionResult[];
+    static getDeclarationsForNode(program: ProgramView, node: NameNode, resolveLocalName: boolean, token: CancellationToken): Declaration[];
     collect(): CollectionResult[];
     walk(node: ParseNode): void;
     visitName(node: NameNode): boolean;
@@ -38,9 +50,6 @@ export declare class DocumentSymbolCollector extends ParseTreeWalker {
     private _resultsContainsDeclaration;
     private _getResolveAliasDeclaration;
     private _setDunderAllNodes;
-    private static _addIfUnique;
-    private static _getDeclarationsForInitNode;
-    private static _getDeclarationsForNode;
-    private static _getDeclarationsForNonModuleNameNode;
-    private static _getDeclarationsForModuleNameNode;
 }
+export declare function getDeclarationsForNameNode(evaluator: TypeEvaluator, node: NameNode, skipUnreachableCode?: boolean): Declaration[];
+export declare function addDeclarationIfUnique(declarations: Declaration[], itemToAdd: Declaration): void;

package/dist/languageService/documentSymbolCollector.js

@@ -28,90 +28,84 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentSymbolCollector = exports.DocumentSymbolCollectorUseCase = void 0;
+exports.addDeclarationIfUnique = exports.getDeclarationsForNameNode = exports.DocumentSymbolCollector = void 0;
 const AnalyzerNodeInfo = __importStar(require("../analyzer/analyzerNodeInfo"));
 const declaration_1 = require("../analyzer/declaration");
 const declarationUtils_1 = require("../analyzer/declarationUtils");
-const ParseTreeUtils = __importStar(require("../analyzer/parseTreeUtils"));
 const parseTreeUtils_1 = require("../analyzer/parseTreeUtils");
 const parseTreeWalker_1 = require("../analyzer/parseTreeWalker");
 const ScopeUtils = __importStar(require("../analyzer/scopeUtils"));
 const sourceFile_1 = require("../analyzer/sourceFile");
 const sourceFileInfoUtils_1 = require("../analyzer/sourceFileInfoUtils");
 const sourceMapper_1 = require("../analyzer/sourceMapper");
-const typeUtils_1 = require("../analyzer/typeUtils");
-const types_1 = require("../analyzer/types");
 const cancellationUtils_1 = require("../common/cancellationUtils");
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const extensibility_1 = require("../common/extensibility");
-var DocumentSymbolCollectorUseCase;
-(function (DocumentSymbolCollectorUseCase) {
-    DocumentSymbolCollectorUseCase[DocumentSymbolCollectorUseCase["Rename"] = 0] = "Rename";
-    DocumentSymbolCollectorUseCase[DocumentSymbolCollectorUseCase["Reference"] = 1] = "Reference";
-})(DocumentSymbolCollectorUseCase = exports.DocumentSymbolCollectorUseCase || (exports.DocumentSymbolCollectorUseCase = {}));
+const serviceProviderExtensions_1 = require("../common/serviceProviderExtensions");
+const core_1 = require("../common/core");
 // This walker looks for symbols that are semantically equivalent
 // to the requested symbol.
 class DocumentSymbolCollector extends parseTreeWalker_1.ParseTreeWalker {
-    constructor(_program, symbolNames, _declarations, _cancellationToken, _startingNode, _treatModuleInImportAndFromImportSame = false, _skipUnreachableCode = true, _useCase = DocumentSymbolCollectorUseCase.Reference) {
+    constructor(_program, symbolNames, declarations, _startingNode, _cancellationToken, options) {
+        var _a, _b, _c, _d, _e;
         super();
         this._program = _program;
-        this._declarations = _declarations;
-        this._cancellationToken = _cancellationToken;
         this._startingNode = _startingNode;
-        this._treatModuleInImportAndFromImportSame = _treatModuleInImportAndFromImportSame;
-        this._skipUnreachableCode = _skipUnreachableCode;
-        this._useCase = _useCase;
+        this._cancellationToken = _cancellationToken;
         this._results = [];
         this._dunderAllNameNodes = new Set();
         this._symbolNames = new Set();
+        this._declarations = [];
         // Start with the symbols passed in
         symbolNames.forEach((s) => this._symbolNames.add(s));
+        this._declarations.push(...declarations);
+        this._treatModuleInImportAndFromImportSame = (_a = options === null || options === void 0 ? void 0 : options.treatModuleInImportAndFromImportSame) !== null && _a !== void 0 ? _a : false;
+        this._skipUnreachableCode = (_b = options === null || options === void 0 ? void 0 : options.skipUnreachableCode) !== null && _b !== void 0 ? _b : true;
+        this._useCase = (_c = options === null || options === void 0 ? void 0 : options.useCase) !== null && _c !== void 0 ? _c : extensibility_1.ReferenceUseCase.References;
+        this._usageProviders =
+            (_d = options === null || options === void 0 ? void 0 : options.providers) !== null && _d !== void 0 ? _d : ((_e = this._program.serviceProvider.tryGet(serviceProviderExtensions_1.ServiceKeys.symbolUsageProviderFactory)) !== null && _e !== void 0 ? _e : [])
+                .map((f) => f.tryCreateProvider(this._useCase, declarations, this._cancellationToken))
+                .filter(core_1.isDefined);
+        if ((options === null || options === void 0 ? void 0 : options.providers) === undefined) {
+            // Check whether we need to add new symbol names and declarations.
+            this._usageProviders.forEach((p) => {
+                p.appendSymbolNamesTo(this._symbolNames);
+                p.appendDeclarationsTo(this._declarations);
+            });
+        }
         // Don't report strings in __all__ right away, that will
         // break the assumption on the result ordering.
         this._setDunderAllNodes(this._startingNode);
-        // Check if one of our symbols is __init__ and we
-        // have a class declaration in the list and we are
-        // computing symbols for references and not rename.
-        const initDeclaration = _declarations.find((d) => d.type === 5 /* Function */ && d.node.name.value === '__init__');
-        if (initDeclaration && _useCase === DocumentSymbolCollectorUseCase.Reference) {
-            const classDeclaration = _declarations.find((d) => d.type === 6 /* Class */);
-            if (classDeclaration) {
-                this._initFunction = initDeclaration.node;
-                this._symbolNames.add(classDeclaration.node.name.value);
-            }
-        }
     }
-    static collectFromNode(program, node, cancellationToken, startingNode, treatModuleInImportAndFromImportSame = false, skipUnreachableCode = true, useCase = DocumentSymbolCollectorUseCase.Reference) {
-        const declarations = this.getDeclarationsForNode(program, node, 
-        /* resolveLocalName */ true, useCase, cancellationToken);
+    static collectFromNode(program, node, cancellationToken, startingNode, options) {
+        const declarations = this.getDeclarationsForNode(program, node, /* resolveLocalName */ true, cancellationToken);
         startingNode = startingNode !== null && startingNode !== void 0 ? startingNode : (0, parseTreeUtils_1.getModuleNode)(node);
         if (!startingNode) {
             return [];
         }
-        const collector = new DocumentSymbolCollector(program, [node.value], declarations, cancellationToken, startingNode, treatModuleInImportAndFromImportSame, skipUnreachableCode, useCase);
+        const collector = new DocumentSymbolCollector(program, [node.value], declarations, startingNode, cancellationToken, options);
         return collector.collect();
     }
-    static getDeclarationsForNode(program, node, resolveLocalName, useCase, token) {
+    static getDeclarationsForNode(program, node, resolveLocalName, token) {
         (0, cancellationUtils_1.throwIfCancellationRequested)(token);
         const evaluator = program.evaluator;
         if (!evaluator) {
             return [];
         }
-        const declarations = this._getDeclarationsForNode(node, useCase, evaluator, token, 
-        /* skipUnreachableCode */ false);
+        const declarations = getDeclarationsForNameNode(evaluator, node, /* skipUnreachableCode */ false);
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const resolvedDeclarations = [];
         const sourceMapper = program.getSourceMapper(fileInfo.filePath, token);
         declarations.forEach((decl) => {
             const resolvedDecl = evaluator.resolveAliasDeclaration(decl, resolveLocalName);
             if (resolvedDecl) {
-                this._addIfUnique(resolvedDeclarations, resolvedDecl);
+                addDeclarationIfUnique(resolvedDeclarations, resolvedDecl);
                 if (sourceMapper && (0, sourceMapper_1.isStubFile)(resolvedDecl.path)) {
                     const implDecls = sourceMapper.findDeclarations(resolvedDecl);
                     for (const implDecl of implDecls) {
                         if (implDecl && implDecl.path) {
-                            this._addIfUnique(resolvedDeclarations, implDecl);
+                            addDeclarationIfUnique(resolvedDeclarations, implDecl);
                         }
                     }
                 }
@@ -143,7 +137,7 @@ class DocumentSymbolCollector extends parseTreeWalker_1.ParseTreeWalker {
             symbol === null || symbol === void 0 ? void 0 : symbol.getDeclarations().filter((d) => !(0, declaration_1.isAliasDeclaration)(d)).forEach((decl) => {
                 const resolvedDecl = evaluator.resolveAliasDeclaration(decl, resolveLocalName);
                 if (resolvedDecl) {
-                    DocumentSymbolCollector._addIfUnique(declarations, resolvedDecl);
+                    addDeclarationIfUnique(declarations, resolvedDecl);
                 }
             });
         }
@@ -164,10 +158,10 @@ class DocumentSymbolCollector extends parseTreeWalker_1.ParseTreeWalker {
             return false;
         }
         if (this._declarations.length > 0) {
-            const declarations = DocumentSymbolCollector._getDeclarationsForNode(node, this._useCase, this._evaluator, this._cancellationToken, this._skipUnreachableCode);
+            const declarations = getDeclarationsForNameNode(this._evaluator, node, this._skipUnreachableCode);
             if (declarations && declarations.length > 0) {
                 // Does this name share a declaration with the symbol of interest?
-                if (declarations.some((decl) => this._resultsContainsDeclaration(decl, node))) {
+                if (this._resultsContainsDeclaration(node, declarations)) {
                     this._addResult(node);
                 }
             }
@@ -203,52 +197,32 @@ class DocumentSymbolCollector extends parseTreeWalker_1.ParseTreeWalker {
         const range = node.nodeType === 38 /* Name */ ? node : (0, parseTreeUtils_1.getStringNodeValueRange)(node);
         this._results.push({ node, range });
     }
-    _isDeclarationAllowed(resolvedDecl, referenceNode) {
-        var _a;
-        // Declaration is allowed if:
-        // Matches one of our declarations.
-        // and --
-        // That match is the right kind.
-        const match = this._declarations.find((decl) => (0, declarationUtils_1.areDeclarationsSame)(decl, resolvedDecl, this._treatModuleInImportAndFromImportSame, 
+    _isDeclarationAllowed(resolvedDecl) {
+        return this._declarations.some((decl) => (0, declarationUtils_1.areDeclarationsSame)(decl, resolvedDecl, this._treatModuleInImportAndFromImportSame, 
         /* skipRangeForAliases */ true));
-        if (match) {
-            // Special case for __init__ being one of our symbol names and we
-            // have a class name as the other.
-            if (this._initFunction) {
-                // If this is a method, must be an __init__ reference.
-                if (match.type === 5 /* Function */) {
-                    return true;
-                }
-                else if (match.type === 6 /* Class */) {
-                    // If this is a class type match, only match on class calls.
-                    // Meaning something like so:
-                    // a = ClassA()
-                    return ((_a = referenceNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */;
-                }
+    }
+    _resultsContainsDeclaration(usage, declarations) {
+        const results = [...declarations];
+        this._usageProviders.forEach((p) => p.appendDeclarationsAt(usage, declarations, results));
+        return results.some((declaration) => {
+            // Resolve the declaration.
+            const resolvedDecl = this._evaluator.resolveAliasDeclaration(declaration, /* resolveLocalNames */ false);
+            if (!resolvedDecl) {
                 return false;
             }
-            return true;
-        }
-        return false;
-    }
-    _resultsContainsDeclaration(declaration, referenceNode) {
-        // Resolve the declaration.
-        const resolvedDecl = this._evaluator.resolveAliasDeclaration(declaration, /* resolveLocalNames */ false);
-        if (!resolvedDecl) {
-            return false;
-        }
-        // The reference results declarations are already resolved, so we don't
-        // need to call resolveAliasDeclaration on them.
-        if (this._isDeclarationAllowed(resolvedDecl, referenceNode)) {
-            return true;
-        }
-        // We didn't find the declaration using local-only alias resolution. Attempt
-        // it again by fully resolving the alias.
-        const resolvedDeclNonlocal = this._getResolveAliasDeclaration(resolvedDecl);
-        if (!resolvedDeclNonlocal || resolvedDeclNonlocal === resolvedDecl) {
-            return false;
-        }
-        return this._isDeclarationAllowed(resolvedDeclNonlocal, referenceNode);
+            // The reference results declarations are already resolved, so we don't
+            // need to call resolveAliasDeclaration on them.
+            if (this._isDeclarationAllowed(resolvedDecl)) {
+                return true;
+            }
+            // We didn't find the declaration using local-only alias resolution. Attempt
+            // it again by fully resolving the alias.
+            const resolvedDeclNonlocal = this._getResolveAliasDeclaration(resolvedDecl);
+            if (!resolvedDeclNonlocal || resolvedDeclNonlocal === resolvedDecl) {
+                return false;
+            }
+            return this._isDeclarationAllowed(resolvedDeclNonlocal);
+        });
     }
     _getResolveAliasDeclaration(declaration) {
         // TypeEvaluator.resolveAliasDeclaration only resolve alias in AliasDeclaration in the form of
@@ -289,209 +263,140 @@ class DocumentSymbolCollector extends parseTreeWalker_1.ParseTreeWalker {
             if (!symbolInScope) {
                 return;
             }
-            if (!symbolInScope.symbol.getDeclarations().some((d) => this._resultsContainsDeclaration(d, stringNode))) {
+            if (!this._resultsContainsDeclaration(stringNode, symbolInScope.symbol.getDeclarations())) {
                 return;
             }
             this._dunderAllNameNodes.add(stringNode);
         });
     }
-    static _addIfUnique(declarations, itemToAdd) {
-        for (const def of declarations) {
-            if ((0, declarationUtils_1.areDeclarationsSame)(def, itemToAdd, 
-            /* treatModuleInImportAndFromImportSame */ false, 
-            /* skipRangeForAliases */ true)) {
-                return;
-            }
-        }
-        declarations.push(itemToAdd);
+}
+exports.DocumentSymbolCollector = DocumentSymbolCollector;
+function getDeclarationsForNameNode(evaluator, node, skipUnreachableCode = true) {
+    var _a;
+    // This can handle symbols brought in by wildcard (import *) as long as the declarations that the symbol collector
+    // compares against point to the actual alias declaration, not one that uses local name (ex, import alias)
+    if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 37 /* ModuleName */) {
+        return _getDeclarationsForNonModuleNameNode(evaluator, node, skipUnreachableCode);
     }
-    static _getDeclarationsForInitNode(node, evaluator) {
-        var _a;
-        const parent = ParseTreeUtils.getEnclosingClassOrFunction(node.parent);
-        // See what type of __init__ we're at.
-        if ((parent === null || parent === void 0 ? void 0 : parent.nodeType) === 10 /* Class */) {
-            // This is a def for '__init__'. We should include the class name too.
-            return this._getDeclarationsForNonModuleNameNode(parent.name, evaluator);
-        }
-        else if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 35 /* MemberAccess */ &&
-            ((node.parent.leftExpression.nodeType === 9 /* Call */ &&
-                node.parent.leftExpression.leftExpression.nodeType === 38 /* Name */ &&
-                node.parent.leftExpression.leftExpression.value === 'super') ||
-                (node.parent.leftExpression.nodeType === 38 /* Name */ &&
-                    node.parent.leftExpression.value === 'super'))) {
-            // We're on the 'super().__init__' call.
-            const decls = evaluator.getDeclarationsForNameNode(node, /* skipUnreachableCode */ true);
-            if (decls && decls.length > 0 && decls[0].node.parent) {
-                // Parent node of the decl should be the class
-                const classNode = ParseTreeUtils.getEnclosingClass(decls[0].node.parent);
-                if (classNode) {
-                    return this._getDeclarationsForNonModuleNameNode(classNode.name, evaluator);
-                }
-            }
+    return _getDeclarationsForModuleNameNode(evaluator, node);
+}
+exports.getDeclarationsForNameNode = getDeclarationsForNameNode;
+function addDeclarationIfUnique(declarations, itemToAdd) {
+    for (const def of declarations) {
+        if ((0, declarationUtils_1.areDeclarationsSame)(def, itemToAdd, 
+        /* treatModuleInImportAndFromImportSame */ false, 
+        /* skipRangeForAliases */ true)) {
+            return;
         }
-        return [];
     }
-    static _getDeclarationsForNode(node, useCase, evaluator, token, skipUnreachableCode = true) {
-        var _a;
-        let result = [];
-        // This can handle symbols brought in by wildcard (import *) as long as the declarations that the symbol collector
-        // compares against point to the actual alias declaration, not one that uses local name (ex, import alias)
-        if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 37 /* ModuleName */) {
-            result = this._getDeclarationsForNonModuleNameNode(node, evaluator, skipUnreachableCode);
-            // Special case for __init__. Might be __init__ on a class.
-            if (node.value === '__init__' && useCase === DocumentSymbolCollectorUseCase.Reference && node.parent) {
-                (0, collectionUtils_1.appendArray)(result, this._getDeclarationsForInitNode(node, evaluator));
-            }
-        }
-        else {
-            result = this._getDeclarationsForModuleNameNode(node, evaluator);
-        }
-        // Let extensions also add declarations.
-        extensibility_1.Extensions.getProgramExtensions(node).forEach((e) => {
-            var _a;
-            const declUseCase = useCase === DocumentSymbolCollectorUseCase.Rename
-                ? extensibility_1.DeclarationUseCase.Rename
-                : extensibility_1.DeclarationUseCase.References;
-            const extras = (_a = e.declarationProviderExtension) === null || _a === void 0 ? void 0 : _a.tryGetDeclarations(evaluator, node, node.start, declUseCase, token);
-            if (extras && extras.length > 0) {
-                (0, collectionUtils_1.appendArray)(result, extras);
-            }
-        });
-        return result;
+    declarations.push(itemToAdd);
+}
+exports.addDeclarationIfUnique = addDeclarationIfUnique;
+function _getDeclarationsForNonModuleNameNode(evaluator, node, skipUnreachableCode = true) {
+    var _a, _b;
+    (0, debug_1.assert)(((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 37 /* ModuleName */);
+    let decls = evaluator.getDeclarationsForNameNode(node, skipUnreachableCode) || [];
+    if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 23 /* ImportFromAs */) {
+        // Make sure we get the decl for this specific "from import" statement
+        decls = decls.filter((d) => d.node === node.parent);
     }
-    static _getDeclarationsForNonModuleNameNode(node, evaluator, skipUnreachableCode = true) {
-        var _a, _b;
-        (0, debug_1.assert)(((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) !== 37 /* ModuleName */);
-        let decls = evaluator.getDeclarationsForNameNode(node, skipUnreachableCode) || [];
-        if (((_b = node.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 23 /* ImportFromAs */) {
-            // Make sure we get the decl for this specific "from import" statement
-            decls = decls.filter((d) => d.node === node.parent);
-        }
-        // If we can't get decl, see whether we can get type from the node.
-        // Some might have synthesized type for the node such as subModule in import X.Y statement.
-        if (decls.length === 0) {
-            const type = evaluator.getType(node);
-            if ((type === null || type === void 0 ? void 0 : type.category) === 8 /* Module */) {
-                // Synthesize decl for the module.
-                return [(0, declarationUtils_1.createSynthesizedAliasDeclaration)(type.filePath)];
-            }
-        }
-        // We would like to make X in import X and import X.Y as Y to match, but path for
-        // X in import X and one in import X.Y as Y might not match since path in X.Y will point
-        // to X.Y rather than X if import statement has an alias.
-        // so, for such case, we put synthesized one so we can treat X in both statement same.
-        for (const aliasDecl of decls.filter((d) => (0, declaration_1.isAliasDeclaration)(d) && !d.loadSymbolsFromPath)) {
-            const node = aliasDecl.node;
-            if (node.nodeType === 23 /* ImportFromAs */) {
-                // from ... import X case, decl in the submodule fallback has the path.
-                continue;
-            }
-            (0, collectionUtils_1.appendArray)(decls, evaluator.getDeclarationsForNameNode(node.module.nameParts[0], skipUnreachableCode) || []);
+    // If we can't get decl, see whether we can get type from the node.
+    // Some might have synthesized type for the node such as subModule in import X.Y statement.
+    if (decls.length === 0) {
+        const type = evaluator.getType(node);
+        if ((type === null || type === void 0 ? void 0 : type.category) === 8 /* Module */) {
+            // Synthesize decl for the module.
+            return [(0, declarationUtils_1.createSynthesizedAliasDeclaration)(type.filePath)];
         }
-        // For now, we only support function overriding.
-        for (const decl of decls.filter((d) => (0, declaration_1.isFunctionDeclaration)(d) && d.isMethod && d.node.name.value.length > 0)) {
-            const methodDecl = decl;
-            const enclosingClass = ParseTreeUtils.getEnclosingClass(methodDecl.node);
-            const classResults = enclosingClass ? evaluator.getTypeOfClass(enclosingClass) : undefined;
-            if (!classResults) {
-                continue;
-            }
-            // Skip init and new as being overloads. They're not really overloads.
-            if (methodDecl.node.name.value === '__init__' || methodDecl.node.name.value === '__new__') {
-                continue;
-            }
-            for (const mroClass of classResults.classType.details.mro) {
-                if ((0, types_1.isInstantiableClass)(mroClass)) {
-                    const currentMember = (0, typeUtils_1.lookUpClassMember)(mroClass, methodDecl.node.name.value);
-                    const baseMember = (0, typeUtils_1.lookUpClassMember)(mroClass, methodDecl.node.name.value, 1 /* SkipOriginalClass */);
-                    if (currentMember && !baseMember) {
-                        // Found base decl of the overridden method. Hold onto the decls.
-                        currentMember.symbol
-                            .getDeclarations()
-                            .filter((d) => (0, declaration_1.isFunctionDeclaration)(d) && d.isMethod)
-                            .forEach((d) => this._addIfUnique(decls, d));
-                    }
-                }
-            }
+    }
+    // We would like to make X in import X and import X.Y as Y to match, but path for
+    // X in import X and one in import X.Y as Y might not match since path in X.Y will point
+    // to X.Y rather than X if import statement has an alias.
+    // so, for such case, we put synthesized one so we can treat X in both statement same.
+    for (const aliasDecl of decls.filter((d) => (0, declaration_1.isAliasDeclaration)(d) && !d.loadSymbolsFromPath)) {
+        const node = aliasDecl.node;
+        if (node.nodeType === 23 /* ImportFromAs */) {
+            // from ... import X case, decl in the submodule fallback has the path.
+            continue;
         }
-        return decls;
+        (0, collectionUtils_1.appendArray)(decls, evaluator.getDeclarationsForNameNode(node.module.nameParts[0], skipUnreachableCode) || []);
     }
-    static _getDeclarationsForModuleNameNode(node, evaluator) {
-        var _a, _b, _c, _d, _e;
-        (0, debug_1.assert)(((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 37 /* ModuleName */);
-        // We don't have symbols corresponding to ModuleName in our system since those
-        // are not referenceable. but in "find all reference", we want to match those
-        // if it refers to the same module file. Code below handles different kind of
-        // ModuleName cases.
-        const moduleName = node.parent;
-        if (((_b = moduleName.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ImportAs */ ||
-            ((_c = moduleName.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 22 /* ImportFrom */) {
-            const index = moduleName.nameParts.findIndex((n) => n === node);
-            // Special case, first module name part.
-            if (index === 0) {
-                // 1. import X or from X import ...
-                const decls = [];
-                // First, we need to put decls for module names type evaluator synthesized so that
-                // we can match both "import X" and "from X import ..."
-                (0, collectionUtils_1.appendArray)(decls, ((_d = evaluator
-                    .getDeclarationsForNameNode(moduleName.nameParts[0])) === null || _d === void 0 ? void 0 : _d.filter((d) => (0, declaration_1.isAliasDeclaration)(d))) || []);
-                if (decls.length === 0 || moduleName.parent.nodeType !== 21 /* ImportAs */) {
-                    return decls;
+    return decls;
+}
+function _getDeclarationsForModuleNameNode(evaluator, node) {
+    var _a, _b, _c, _d, _e;
+    (0, debug_1.assert)(((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 37 /* ModuleName */);
+    // We don't have symbols corresponding to ModuleName in our system since those
+    // are not referenceable. but in "find all reference", we want to match those
+    // if it refers to the same module file. Code below handles different kind of
+    // ModuleName cases.
+    const moduleName = node.parent;
+    if (((_b = moduleName.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 21 /* ImportAs */ ||
+        ((_c = moduleName.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 22 /* ImportFrom */) {
+        const index = moduleName.nameParts.findIndex((n) => n === node);
+        // Special case, first module name part.
+        if (index === 0) {
+            // 1. import X or from X import ...
+            const decls = [];
+            // First, we need to put decls for module names type evaluator synthesized so that
+            // we can match both "import X" and "from X import ..."
+            (0, collectionUtils_1.appendArray)(decls, ((_d = evaluator.getDeclarationsForNameNode(moduleName.nameParts[0])) === null || _d === void 0 ? void 0 : _d.filter((d) => (0, declaration_1.isAliasDeclaration)(d))) ||
+                []);
+            if (decls.length === 0 || moduleName.parent.nodeType !== 21 /* ImportAs */) {
+                return decls;
+            }
+            // If module name belong to "import xxx" not "from xxx", then see whether
+            // we can get regular decls (decls created from binder, not synthesized from type eval)
+            // from symbol as well.
+            // ex, import X as x
+            const isImportAsWithAlias = moduleName.nameParts.length === 1 &&
+                moduleName.parent.nodeType === 21 /* ImportAs */ &&
+                !!moduleName.parent.alias;
+            // if "import" has alias, symbol is assigned to alias, not the module.
+            const importName = isImportAsWithAlias
+                ? moduleName.parent.alias.value
+                : moduleName.nameParts[0].value;
+            // And we also need to re-use "decls for X" binder has created
+            // so that it matches with decls type evaluator returns for "references for X".
+            // ex) import X or from .X import ... in init file and etc.
+            const symbolWithScope = (_e = ScopeUtils.getScopeForNode(node)) === null || _e === void 0 ? void 0 : _e.lookUpSymbolRecursive(importName);
+            if (symbolWithScope && moduleName.nameParts.length === 1) {
+                let declsFromSymbol = [];
+                (0, collectionUtils_1.appendArray)(declsFromSymbol, symbolWithScope.symbol.getDeclarations().filter((d) => (0, declaration_1.isAliasDeclaration)(d)));
+                // If symbols are re-used, then find one that belong to this import statement.
+                if (declsFromSymbol.length > 1) {
+                    declsFromSymbol = declsFromSymbol.filter((d) => {
+                        d = d;
+                        if (d.firstNamePart !== undefined) {
+                            // For multiple import statements with sub modules, decl can be re-used.
+                            // ex) import X.Y and import X.Z or from .X import ... in init file.
+                            // Decls for X will be reused for both import statements, and node will point
+                            // to first import statement. For those case, use firstNamePart instead to check.
+                            return d.firstNamePart === moduleName.nameParts[0].value;
+                        }
+                        return d.node === moduleName.parent;
+                    });
                 }
-                // If module name belong to "import xxx" not "from xxx", then see whether
-                // we can get regular decls (decls created from binder, not synthesized from type eval)
-                // from symbol as well.
                 // ex, import X as x
-                const isImportAsWithAlias = moduleName.nameParts.length === 1 &&
-                    moduleName.parent.nodeType === 21 /* ImportAs */ &&
-                    !!moduleName.parent.alias;
-                // if "import" has alias, symbol is assigned to alias, not the module.
-                const importName = isImportAsWithAlias
-                    ? moduleName.parent.alias.value
-                    : moduleName.nameParts[0].value;
-                // And we also need to re-use "decls for X" binder has created
-                // so that it matches with decls type evaluator returns for "references for X".
-                // ex) import X or from .X import ... in init file and etc.
-                const symbolWithScope = (_e = ScopeUtils.getScopeForNode(node)) === null || _e === void 0 ? void 0 : _e.lookUpSymbolRecursive(importName);
-                if (symbolWithScope && moduleName.nameParts.length === 1) {
-                    let declsFromSymbol = [];
-                    (0, collectionUtils_1.appendArray)(declsFromSymbol, symbolWithScope.symbol.getDeclarations().filter((d) => (0, declaration_1.isAliasDeclaration)(d)));
-                    // If symbols are re-used, then find one that belong to this import statement.
-                    if (declsFromSymbol.length > 1) {
-                        declsFromSymbol = declsFromSymbol.filter((d) => {
-                            d = d;
-                            if (d.firstNamePart !== undefined) {
-                                // For multiple import statements with sub modules, decl can be re-used.
-                                // ex) import X.Y and import X.Z or from .X import ... in init file.
-                                // Decls for X will be reused for both import statements, and node will point
-                                // to first import statement. For those case, use firstNamePart instead to check.
-                                return d.firstNamePart === moduleName.nameParts[0].value;
-                            }
-                            return d.node === moduleName.parent;
-                        });
-                    }
-                    // ex, import X as x
-                    // We have decls for the alias "x" not the module name "X". Convert decls for the "X"
-                    if (isImportAsWithAlias) {
-                        declsFromSymbol = (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsFromSymbol);
-                    }
-                    (0, collectionUtils_1.appendArray)(decls, declsFromSymbol);
+                // We have decls for the alias "x" not the module name "X". Convert decls for the "X"
+                if (isImportAsWithAlias) {
+                    declsFromSymbol = (0, declarationUtils_1.getDeclarationsWithUsesLocalNameRemoved)(declsFromSymbol);
                 }
-                return decls;
-            }
-            if (index > 0) {
-                // 2. import X.Y or from X.Y import ....
-                // For submodule "Y", we just use synthesized decls from type evaluator.
-                // Decls for these sub module don't actually exist in the system. Instead, symbol for Y in
-                // "import X.Y" hold onto synthesized module type (without any decl).
-                // And "from X.Y import ..." doesn't have any symbol associated module names.
-                // they can't be referenced in the module.
-                return evaluator.getDeclarationsForNameNode(moduleName.nameParts[index]) || [];
+                (0, collectionUtils_1.appendArray)(decls, declsFromSymbol);
             }
-            return [];
+            return decls;
+        }
+        if (index > 0) {
+            // 2. import X.Y or from X.Y import ....
+            // For submodule "Y", we just use synthesized decls from type evaluator.
+            // Decls for these sub module don't actually exist in the system. Instead, symbol for Y in
+            // "import X.Y" hold onto synthesized module type (without any decl).
+            // And "from X.Y import ..." doesn't have any symbol associated module names.
+            // they can't be referenced in the module.
+            return evaluator.getDeclarationsForNameNode(moduleName.nameParts[index]) || [];
         }
         return [];
     }
+    return [];
 }
-exports.DocumentSymbolCollector = DocumentSymbolCollector;
 //# sourceMappingURL=documentSymbolCollector.js.map