@zzzen/pyright-internal 1.2.0-dev.20230226 → 1.2.0-dev.20230312

package/dist/analyzer/binder.d.ts

@@ -128,7 +128,6 @@ export declare class Binder extends ParseTreeWalker {
     private _isAnnotationClassVar;
     private _isRequiredAnnotation;
     private _isNotRequiredAnnotation;
-    private _isAnnotationTypeAlias;
     private _getMemberAccessInfo;
     private _addImplicitImportsToLoaderActions;
     private _handleTypingStubAssignmentOrAnnotation;

package/dist/analyzer/binder.js

@@ -46,6 +46,7 @@ const textRange_1 = require("../common/textRange");
 const localize_1 = require("../localization/localize");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const codeFlowTypes_1 = require("./codeFlowTypes");
+const declaration_1 = require("./declaration");
 const docStringUtils_1 = require("./docStringUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const parseTreeWalker_1 = require("./parseTreeWalker");
@@ -1268,7 +1269,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitImportFrom(node) {
         var _a;
-        const typingSymbolsOfInterest = ['Final', 'TypeAlias', 'ClassVar', 'Required', 'NotRequired', 'Annotated'];
+        const typingSymbolsOfInterest = ['Final', 'ClassVar', 'Annotated'];
         const dataclassesSymbolsOfInterest = ['InitVar'];
         const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
         let resolvedPath = '';
@@ -1906,7 +1907,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             pathOfLastSubmodule = importInfo.resolvedPaths[importInfo.resolvedPaths.length - 1];
         }
         else {
-            pathOfLastSubmodule = '*** unresolved ***';
+            pathOfLastSubmodule = declaration_1.UnresolvedModuleMarker;
         }
         const isResolved = importInfo && importInfo.isImportFound && !importInfo.isNativeLib && importInfo.resolvedPaths.length > 0;
         if (existingDecl) {
@@ -1920,7 +1921,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 loadSymbolsFromPath: false,
                 range: (0, textRange_1.getEmptyRange)(),
                 usesLocalName: !!importAlias,
-                moduleName: importInfo.importName,
+                moduleName: firstNamePartValue,
                 firstNamePart: firstNamePartValue,
                 isInExceptSuite: this._isInExceptSuite,
             };
@@ -1942,6 +1943,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 isInExceptSuite: this._isInExceptSuite,
             };
         }
+        // See if there is import info for this part of the path. This allows us
+        // to implicitly import all of the modules in a multi-part module name.
+        const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.module.nameParts[0]);
+        if (implicitImportInfo && implicitImportInfo.resolvedPaths.length) {
+            newDecl.path = implicitImportInfo.resolvedPaths[0];
+            newDecl.loadSymbolsFromPath = true;
+            this._addImplicitImportsToLoaderActions(implicitImportInfo, newDecl);
+        }
         // Add the implicit imports for this module if it's the last
         // name part we're resolving.
         if (importAlias || node.module.nameParts.length === 1) {
@@ -1964,7 +1973,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 if (!loaderActions) {
                     const loaderActionPath = importInfo && i < importInfo.resolvedPaths.length
                         ? importInfo.resolvedPaths[i]
-                        : '*** unresolved ***';
+                        : declaration_1.UnresolvedModuleMarker;
                     // Allocate a new loader action.
                     loaderActions = {
                         path: loaderActionPath,
@@ -1977,15 +1986,27 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     curLoaderActions.implicitImports.set(namePartValue, loaderActions);
                 }
-                // If this is the last name part we're resolving, add in the
-                // implicit imports as well.
                 if (i === node.module.nameParts.length - 1) {
+                    // If this is the last name part we're resolving, add in the
+                    // implicit imports as well.
                     if (importInfo && i < importInfo.resolvedPaths.length) {
                         loaderActions.path = importInfo.resolvedPaths[i];
                         loaderActions.loadSymbolsFromPath = true;
                         this._addImplicitImportsToLoaderActions(importInfo, loaderActions);
                     }
                 }
+                else {
+                    // If this isn't the last name part we're resolving, see if there
+                    // is import info for this part of the path. This allows us to implicitly
+                    // import all of the modules in a multi-part module name (e.g. "import a.b.c"
+                    // imports "a" and "a.b" and "a.b.c").
+                    const implicitImportInfo = AnalyzerNodeInfo.getImportInfo(node.module.nameParts[i]);
+                    if (implicitImportInfo && implicitImportInfo.resolvedPaths.length) {
+                        loaderActions.path = implicitImportInfo.resolvedPaths[i];
+                        loaderActions.loadSymbolsFromPath = true;
+                        this._addImplicitImportsToLoaderActions(implicitImportInfo, loaderActions);
+                    }
+                }
                 curLoaderActions = loaderActions;
             }
         }
@@ -2764,21 +2785,8 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 const symbolWithScope = this._currentScope.lookUpSymbolRecursive(name.value);
                 if (symbolWithScope && symbolWithScope.symbol) {
                     const finalInfo = this._isAnnotationFinal(typeAnnotation);
-                    const isExplicitTypeAlias = this._isAnnotationTypeAlias(typeAnnotation);
                     let typeAnnotationNode = typeAnnotation;
-                    let innerTypeAnnotationNode = typeAnnotation;
-                    if (isExplicitTypeAlias) {
-                        typeAnnotationNode = undefined;
-                        innerTypeAnnotationNode = undefined;
-                        // Type aliases are allowed only in the global or class scope.
-                        if (this._currentScope.type !== 2 /* Class */ &&
-                            this._currentScope.type !== 3 /* Module */ &&
-                            this._currentScope.type !== 4 /* Builtin */) {
-                            this._addError(localize_1.Localizer.Diagnostic.typeAliasNotInModuleOrClass(), typeAnnotation);
-                        }
-                    }
-                    else if (finalInfo.isFinal) {
-                        innerTypeAnnotationNode = finalInfo.finalTypeNode;
+                    if (finalInfo.isFinal) {
                         if (!finalInfo.finalTypeNode) {
                             typeAnnotationNode = undefined;
                         }
@@ -2786,7 +2794,6 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     // Is this annotation indicating that the variable is a "ClassVar"?
                     let classVarInfo = this._isAnnotationClassVar(typeAnnotation);
                     if (classVarInfo.isClassVar) {
-                        innerTypeAnnotationNode = classVarInfo.classVarTypeNode;
                         if (!classVarInfo.classVarTypeNode) {
                             typeAnnotationNode = undefined;
                         }
@@ -2811,11 +2818,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         node: target,
                         isConstant: (0, symbolNameUtils_1.isConstantName)(name.value),
                         isFinal: finalInfo.isFinal,
-                        isClassVar: classVarInfo.isClassVar,
-                        isRequired: this._isRequiredAnnotation(innerTypeAnnotationNode),
-                        isNotRequired: this._isNotRequiredAnnotation(innerTypeAnnotationNode),
-                        typeAliasAnnotation: isExplicitTypeAlias ? typeAnnotation : undefined,
-                        typeAliasName: isExplicitTypeAlias ? target : undefined,
+                        typeAliasName: target,
                         path: this._fileInfo.filePath,
                         typeAnnotationNode,
                         range: (0, positionUtils_1.convertTextRangeToRange)(name, this._fileInfo.lines),
@@ -2929,72 +2932,12 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     _getVariableDocString(node) {
-        var _a, _b, _c, _d;
-        // Walk up the parse tree to find an assignment expression.
-        let curNode = node;
-        let annotationNode;
-        while (curNode) {
-            if (curNode.nodeType === 3 /* Assignment */) {
-                break;
-            }
-            if (curNode.nodeType === 54 /* TypeAnnotation */ && !annotationNode) {
-                annotationNode = curNode;
-            }
-            curNode = curNode.parent;
-        }
-        if ((curNode === null || curNode === void 0 ? void 0 : curNode.nodeType) !== 3 /* Assignment */) {
-            // Allow a simple annotation statement to have a docstring even
-            // though PEP 258 doesn't mention this case. This PEP pre-dated
-            // PEP 526, so it didn't contemplate this situation.
-            if (annotationNode) {
-                curNode = annotationNode;
-            }
-            else {
-                return undefined;
-            }
-        }
-        const parentNode = curNode.parent;
-        if ((parentNode === null || parentNode === void 0 ? void 0 : parentNode.nodeType) !== 47 /* StatementList */) {
-            return undefined;
-        }
-        const suiteOrModule = parentNode.parent;
-        if (!suiteOrModule ||
-            (suiteOrModule.nodeType !== 36 /* Module */ && suiteOrModule.nodeType !== 50 /* Suite */)) {
-            return undefined;
-        }
-        const assignmentIndex = suiteOrModule.statements.findIndex((node) => node === parentNode);
-        if (assignmentIndex < 0 || assignmentIndex === suiteOrModule.statements.length - 1) {
-            return undefined;
-        }
-        const nextStatement = suiteOrModule.statements[assignmentIndex + 1];
-        if (nextStatement.nodeType !== 47 /* StatementList */ || !ParseTreeUtils.isDocString(nextStatement)) {
-            return undefined;
-        }
-        // See if the assignment is within one of the contexts specified in PEP 258.
-        let isValidContext = false;
-        if (((_a = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 36 /* Module */) {
-            // If we're at the top level of a module, the attribute docstring is valid.
-            isValidContext = true;
-        }
-        else if (((_b = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 50 /* Suite */ &&
-            ((_d = (_c = parentNode === null || parentNode === void 0 ? void 0 : parentNode.parent) === null || _c === void 0 ? void 0 : _c.parent) === null || _d === void 0 ? void 0 : _d.nodeType) === 10 /* Class */) {
-            // If we're at the top level of a class, the attribute docstring is valid.
-            isValidContext = true;
-        }
-        else {
-            const func = ParseTreeUtils.getEnclosingFunction(parentNode);
-            // If we're within an __init__ method, the attribute docstring is valid.
-            if (func &&
-                func.name.value === '__init__' &&
-                ParseTreeUtils.getEnclosingClass(func, /* stopAtFunction */ true)) {
-                isValidContext = true;
-            }
-        }
-        if (!isValidContext) {
+        const docNode = ParseTreeUtils.getVariableDocStringNode(node);
+        if (!docNode) {
             return undefined;
         }
         // A docstring can consist of multiple joined strings in a single expression.
-        const strings = nextStatement.statements[0].strings;
+        const strings = docNode.strings;
         if (strings.length === 1) {
             // Common case.
             return strings[0].value;
@@ -3081,12 +3024,6 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         return false;
     }
-    _isAnnotationTypeAlias(typeAnnotation) {
-        if (!typeAnnotation) {
-            return false;
-        }
-        return this._isTypingAnnotation(typeAnnotation, 'TypeAlias');
-    }
     // Determines whether a member access expression is referring to a
     // member of a class (either a class or instance member). This will
     // typically take the form "self.x" or "cls.x".