@zzzen/pyright-internal 1.2.0-dev.2022-07-02 → 1.2.0-dev.20220717

package/dist/analyzer/binder.js

@@ -65,6 +65,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._moduleSymbolOnly = _moduleSymbolOnly;
         // A queue of deferred analysis operations.
         this._deferredBindingTasks = [];
+        // Tracks the type parameters that are currently active within the
+        // scope and any outer scopes.
+        this._activeTypeParams = new Map();
         // Flow nodes used within try blocks.
         this._currentExceptTargets = [];
         // Flow nodes used within try/finally flows.
@@ -207,19 +210,22 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     visitClass(node) {
         this.walkMultiple(node.decorators);
         const classDeclaration = {
-            type: 4 /* Class */,
+            type: 6 /* Class */,
             node,
             path: this._fileInfo.filePath,
             range: (0, positionUtils_1.convertOffsetsToRange)(node.name.start, textRange_2.TextRange.getEnd(node.name), this._fileInfo.lines),
             moduleName: this._fileInfo.moduleName,
             isInExceptSuite: this._isInExceptSuite,
         };
-        const symbol = this._bindNameToScope(this._currentScope, node.name.value);
+        const symbol = this._bindNameToScope(this._currentScope, node.name);
         if (symbol) {
             symbol.addDeclaration(classDeclaration);
         }
         // Stash the declaration in the parse node for later access.
         AnalyzerNodeInfo.setDeclaration(node, classDeclaration);
+        if (node.typeParameters) {
+            this.walk(node.typeParameters);
+        }
         this.walkMultiple(node.arguments);
         this._createNewScope(2 /* Class */, this._getNonClassParentScope(), () => {
             AnalyzerNodeInfo.setScope(node, this._currentScope);
@@ -236,15 +242,18 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._dunderSlotsEntries = undefined;
         });
         this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ false, /* unbound */ false);
+        if (node.typeParameters) {
+            this._removeActiveTypeParameters(node.typeParameters);
+        }
         return false;
     }
     visitFunction(node) {
         this._createVariableAnnotationFlowNode();
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
-        const symbol = this._bindNameToScope(this._currentScope, node.name.value);
+        const symbol = this._bindNameToScope(this._currentScope, node.name);
         const containingClassNode = ParseTreeUtils.getEnclosingClass(node, /* stopAtFunction */ true);
         const functionDeclaration = {
-            type: 3 /* Function */,
+            type: 5 /* Function */,
             node,
             isMethod: !!containingClassNode,
             isGenerator: false,
@@ -258,11 +267,17 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         // Stash the declaration in the parse node for later access.
         AnalyzerNodeInfo.setDeclaration(node, functionDeclaration);
-        this.walkMultiple(node.decorators);
+        // Walk the default values prior to the type parameters.
         node.parameters.forEach((param) => {
             if (param.defaultValue) {
                 this.walk(param.defaultValue);
             }
+        });
+        if (node.typeParameters) {
+            this.walk(node.typeParameters);
+        }
+        this.walkMultiple(node.decorators);
+        node.parameters.forEach((param) => {
             if (param.typeAnnotation) {
                 this.walk(param.typeAnnotation);
             }
@@ -291,7 +306,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._codeFlowComplexity = 0;
                 node.parameters.forEach((paramNode) => {
                     if (paramNode.name) {
-                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name.value);
+                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name);
                         if (symbol) {
                             const paramDeclaration = {
                                 type: 2 /* Parameter */,
@@ -325,6 +340,9 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             });
         });
         this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ false, /* unbound */ false);
+        if (node.typeParameters) {
+            this._removeActiveTypeParameters(node.typeParameters);
+        }
         // We'll walk the child nodes in a deferred manner, so don't walk them now.
         return false;
     }
@@ -345,7 +363,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._currentFlowNode = this._createStartFlowNode();
                 node.parameters.forEach((paramNode) => {
                     if (paramNode.name) {
-                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name.value);
+                        const symbol = this._bindNameToScope(this._currentScope, paramNode.name);
                         if (symbol) {
                             const paramDeclaration = {
                                 type: 2 /* Parameter */,
@@ -360,6 +378,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         this._createFlowAssignment(paramNode.name);
                         this.walk(paramNode.name);
+                        AnalyzerNodeInfo.setFlowNode(paramNode, this._currentFlowNode);
                     }
                 });
                 // Walk the expression that make up the lambda body.
@@ -455,6 +474,62 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         return false;
     }
+    visitTypeParameterList(node) {
+        node.parameters.forEach((param) => {
+            if (param.boundExpression) {
+                this.walk(param.boundExpression);
+            }
+        });
+        node.parameters.forEach((param) => {
+            const name = param.name;
+            const symbol = new symbol_1.Symbol(0 /* None */);
+            const paramDeclaration = {
+                type: 3 /* TypeParameter */,
+                node: param,
+                path: this._fileInfo.filePath,
+                range: (0, positionUtils_1.convertOffsetsToRange)(node.start, textRange_2.TextRange.getEnd(node), this._fileInfo.lines),
+                moduleName: this._fileInfo.moduleName,
+                isInExceptSuite: this._isInExceptSuite,
+            };
+            symbol.addDeclaration(paramDeclaration);
+            AnalyzerNodeInfo.setDeclaration(name, paramDeclaration);
+            AnalyzerNodeInfo.setTypeParameterSymbol(name, symbol);
+            if (this._activeTypeParams.has(name.value)) {
+                this._addError(localize_1.Localizer.Diagnostic.typeParameterExistingTypeParameter().format({ name: name.value }), name);
+            }
+            else {
+                this._activeTypeParams.set(name.value, symbol);
+            }
+        });
+        return false;
+    }
+    visitTypeAlias(node) {
+        this._bindNameToScope(this._currentScope, node.name);
+        this.walk(node.name);
+        if (node.typeParameters) {
+            this.walk(node.typeParameters);
+        }
+        const typeAliasDeclaration = {
+            type: 4 /* TypeAlias */,
+            node,
+            path: this._fileInfo.filePath,
+            range: (0, positionUtils_1.convertOffsetsToRange)(node.name.start, textRange_2.TextRange.getEnd(node.name), this._fileInfo.lines),
+            moduleName: this._fileInfo.moduleName,
+            isInExceptSuite: this._isInExceptSuite,
+        };
+        const symbol = this._bindNameToScope(this._currentScope, node.name);
+        if (symbol) {
+            symbol.addDeclaration(typeAliasDeclaration);
+        }
+        // Stash the declaration in the parse node for later access.
+        AnalyzerNodeInfo.setDeclaration(node, typeAliasDeclaration);
+        this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
+        this.walk(node.expression);
+        if (node.typeParameters) {
+            this._removeActiveTypeParameters(node.typeParameters);
+        }
+        return false;
+    }
     visitAssignment(node) {
         if (this._handleTypingStubAssignmentOrAnnotation(node)) {
             return false;
@@ -475,6 +550,20 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             this._createAssignmentTargetFlowNodes(node.leftExpression, /* walkTargets */ true, /* unbound */ false);
             createdAssignmentTargetFlowNodes = true;
         }
+        // If the assignment target base expression is potentially a
+        // TypedDict, add the base expression to the flow expressions set
+        // to accommodate TypedDict type narrowing.
+        if (node.leftExpression.nodeType === 24 /* Index */) {
+            const target = node.leftExpression;
+            if (target.items.length === 1 &&
+                !target.trailingComma &&
+                target.items[0].valueExpression.nodeType === 48 /* StringList */) {
+                if ((0, codeFlowTypes_1.isCodeFlowSupportedForReference)(target.baseExpression)) {
+                    const baseExprReferenceKey = (0, codeFlowTypes_1.createKeyForReference)(target.baseExpression);
+                    this._currentScopeCodeFlowExpressions.add(baseExprReferenceKey);
+                }
+            }
+        }
         this.walk(node.rightExpression);
         let isPossibleTypeAlias = true;
         if (ParseTreeUtils.getEnclosingFunction(node)) {
@@ -617,7 +706,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 curScope = curScope.parent;
             }
-            this._bindNameToScope(containerScope, node.name.value);
+            this._bindNameToScope(containerScope, node.name);
             this._addInferredTypeAssignmentForVariable(node.name, node.rightExpression);
             this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
         }
@@ -794,6 +883,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     visitName(node) {
         AnalyzerNodeInfo.setFlowNode(node, this._currentFlowNode);
+        const typeParamSymbol = this._activeTypeParams.get(node.value);
+        if (typeParamSymbol) {
+            AnalyzerNodeInfo.setTypeParameterSymbol(node, typeParamSymbol);
+        }
         // Name nodes have no children.
         return false;
     }
@@ -876,7 +969,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (node.name) {
             this.walk(node.name);
-            const symbol = this._bindNameToScope(this._currentScope, node.name.value);
+            const symbol = this._bindNameToScope(this._currentScope, node.name);
             this._createAssignmentTargetFlowNodes(node.name, /* walkTargets */ true, /* unbound */ false);
             if (symbol) {
                 const declaration = {
@@ -1047,7 +1140,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // Make sure this is within an async lambda or function.
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(node);
         if (enclosingFunction === undefined || !enclosingFunction.isAsync) {
-            if (this._fileInfo.isIPythonMode && enclosingFunction === undefined) {
+            if (this._fileInfo.ipythonMode && enclosingFunction === undefined) {
                 // Top level await is allowed in ipython mode.
                 return true;
             }
@@ -1074,7 +1167,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                 this._addError(localize_1.Localizer.Diagnostic.globalReassignment().format({ name: nameValue }), name);
             }
             // Add it to the global scope if it's not already added.
-            this._bindNameToScope(globalScope, nameValue);
+            this._bindNameToScope(globalScope, name);
             if (this._currentScope !== globalScope) {
                 this._currentScope.setBindingType(nameValue, 1 /* Global */);
             }
@@ -1113,16 +1206,19 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         if (node.module.nameParts.length > 0) {
             const firstNamePartValue = node.module.nameParts[0].value;
             let symbolName;
+            let symbolNameNode;
             if (node.alias) {
                 // The symbol name is defined by the alias.
                 symbolName = node.alias.value;
+                symbolNameNode = node.alias;
             }
             else {
                 // There was no alias, so we need to use the first element of
                 // the name parts as the symbol.
                 symbolName = firstNamePartValue;
+                symbolNameNode = node.module.nameParts[0];
             }
-            const symbol = this._bindNameToScope(this._currentScope, symbolName);
+            const symbol = this._bindNameToScope(this._currentScope, symbolNameNode);
             if (symbol &&
                 (this._currentScope.type === 3 /* Module */ || this._currentScope.type === 4 /* Builtin */) &&
                 (!node.alias ||
@@ -1203,14 +1299,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     wildcardNames.forEach((name) => {
-                        const localSymbol = this._bindNameToScope(this._currentScope, name);
+                        const localSymbol = this._bindNameValueToScope(this._currentScope, name);
                         if (localSymbol) {
                             const importedSymbol = lookupInfo.symbolTable.get(name);
                             // Is the symbol in the target module's symbol table? If so,
                             // alias it.
                             if (importedSymbol) {
                                 const aliasDecl = {
-                                    type: 6 /* Alias */,
+                                    type: 8 /* Alias */,
                                     node,
                                     path: resolvedPath,
                                     loadSymbolsFromPath: true,
@@ -1230,7 +1326,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                     const implicitImport = importInfo.filteredImplicitImports.find((imp) => imp.name === name);
                                     if (implicitImport) {
                                         const submoduleFallback = {
-                                            type: 6 /* Alias */,
+                                            type: 8 /* Alias */,
                                             node,
                                             path: implicitImport.path,
                                             loadSymbolsFromPath: true,
@@ -1240,7 +1336,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                             isInExceptSuite: this._isInExceptSuite,
                                         };
                                         const aliasDecl = {
-                                            type: 6 /* Alias */,
+                                            type: 8 /* Alias */,
                                             node,
                                             path: resolvedPath,
                                             loadSymbolsFromPath: true,
@@ -1278,7 +1374,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             node.imports.forEach((importSymbolNode) => {
                 const importedName = importSymbolNode.name.value;
                 const nameNode = importSymbolNode.alias || importSymbolNode.name;
-                const symbol = this._bindNameToScope(this._currentScope, nameNode.value);
+                const symbol = this._bindNameToScope(this._currentScope, nameNode);
                 if (symbol) {
                     // All import statements of the form `from . import x` treat x
                     // as an externally-visible (not hidden) symbol.
@@ -1306,7 +1402,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                     let loadSymbolsFromPath = true;
                     if (implicitImport) {
                         submoduleFallback = {
-                            type: 6 /* Alias */,
+                            type: 8 /* Alias */,
                             node: importSymbolNode,
                             path: implicitImport.path,
                             loadSymbolsFromPath: true,
@@ -1325,7 +1421,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     const aliasDecl = {
-                        type: 6 /* Alias */,
+                        type: 8 /* Alias */,
                         node: importSymbolNode,
                         path: resolvedPath,
                         loadSymbolsFromPath,
@@ -1605,7 +1701,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._currentFlowNode = this._finishFlowLabel(postOrLabel);
         if (node.target) {
             this.walk(node.target);
-            const symbol = this._bindNameToScope(this._currentScope, node.target.value);
+            const symbol = this._bindNameToScope(this._currentScope, node.target);
             this._createAssignmentTargetFlowNodes(node.target, /* walkTargets */ false, /* unbound */ false);
             if (symbol) {
                 const declaration = {
@@ -1635,6 +1731,18 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         return true;
     }
+    _removeActiveTypeParameters(node) {
+        node.parameters.forEach((typeParamNode) => {
+            const entry = this._activeTypeParams.get(typeParamNode.name.value);
+            if (entry) {
+                const decls = entry.getDeclarations();
+                (0, debug_1.assert)(decls && decls.length === 1 && decls[0].type === 3 /* TypeParameter */);
+                if (decls[0].node === typeParamNode) {
+                    this._activeTypeParams.delete(typeParamNode.name.value);
+                }
+            }
+        });
+    }
     _getNonClassParentScope() {
         // We may not be able to use the current scope if it's a class scope.
         // Walk up until we find a non-class scope instead.
@@ -1700,7 +1808,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         return false;
     }
     _addPatternCaptureTarget(target) {
-        const symbol = this._bindNameToScope(this._currentScope, target.value);
+        const symbol = this._bindNameToScope(this._currentScope, target);
         this._createAssignmentTargetFlowNodes(target, /* walkTargets */ false, /* unbound */ false);
         if (symbol) {
             const declaration = {
@@ -1731,7 +1839,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             return undefined;
         }
         // There should be only one declaration for the variable.
-        const aliasDecl = varSymbol.getDeclarations().find((decl) => decl.type === 6 /* Alias */);
+        const aliasDecl = varSymbol.getDeclarations().find((decl) => decl.type === 8 /* Alias */);
         const resolvedPath = (aliasDecl === null || aliasDecl === void 0 ? void 0 : aliasDecl.path) && aliasDecl.loadSymbolsFromPath
             ? aliasDecl.path
             : ((_a = aliasDecl === null || aliasDecl === void 0 ? void 0 : aliasDecl.submoduleFallback) === null || _a === void 0 ? void 0 : _a.path) && aliasDecl.submoduleFallback.loadSymbolsFromPath
@@ -1748,7 +1856,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     }
     _addImplicitFromImport(node, importInfo) {
         const symbolName = node.module.nameParts[0].value;
-        const symbol = this._bindNameToScope(this._currentScope, symbolName);
+        const symbol = this._bindNameValueToScope(this._currentScope, symbolName);
         if (symbol) {
             this._createAliasDeclarationForMultipartImportName(node, /* importAlias */ undefined, importInfo, symbol);
         }
@@ -1766,7 +1874,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         // python module loader.
         const existingDecl = symbol
             .getDeclarations()
-            .find((decl) => decl.type === 6 /* Alias */ && decl.firstNamePart === firstNamePartValue);
+            .find((decl) => decl.type === 8 /* Alias */ && decl.firstNamePart === firstNamePartValue);
         let newDecl;
         let pathOfLastSubmodule;
         if (importInfo && importInfo.isImportFound && !importInfo.isNativeLib && importInfo.resolvedPaths.length > 0) {
@@ -1781,7 +1889,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         else if (isResolved) {
             newDecl = {
-                type: 6 /* Alias */,
+                type: 8 /* Alias */,
                 node,
                 path: pathOfLastSubmodule,
                 loadSymbolsFromPath: false,
@@ -1797,7 +1905,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // bogus path so it gets an unknown type (rather than an unbound type) at
             // analysis time.
             newDecl = {
-                type: 6 /* Alias */,
+                type: 8 /* Alias */,
                 node,
                 path: pathOfLastSubmodule,
                 loadSymbolsFromPath: true,
@@ -2388,7 +2496,14 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    _bindNameToScope(scope, name, addedSymbols) {
+    _bindNameToScope(scope, node, addedSymbols) {
+        // Is this name already used by an active type parameter?
+        if (this._activeTypeParams.get(node.value)) {
+            this._addError(localize_1.Localizer.Diagnostic.overwriteTypeParameter().format({ name: node.value }), node);
+        }
+        return this._bindNameValueToScope(scope, node.value, addedSymbols);
+    }
+    _bindNameValueToScope(scope, name, addedSymbols) {
         // Is this name already bound to a scope other than the local one?
         const bindingType = this._currentScope.getBindingType(name);
         if (bindingType !== undefined) {
@@ -2436,7 +2551,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
     _bindPossibleTupleNamedTarget(target, addedSymbols) {
         switch (target.nodeType) {
             case 38 /* Name */: {
-                this._bindNameToScope(this._currentScope, target.value, addedSymbols);
+                this._bindNameToScope(this._currentScope, target, addedSymbols);
                 break;
             }
             case 52 /* Tuple */: {
@@ -2554,7 +2669,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         if (!symbol.isClassMember() ||
                             !symbol
                                 .getDeclarations()
-                                .some((decl) => decl.type === 3 /* Function */ && decl.isMethod)) {
+                                .some((decl) => decl.type === 5 /* Function */ && decl.isMethod)) {
                             symbol.setIsInstanceMember();
                         }
                     }
@@ -3067,10 +3182,10 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         if (!specialTypes.has(assignedName)) {
             return false;
         }
-        const symbol = this._bindNameToScope(this._currentScope, assignedName);
+        const symbol = this._bindNameToScope(this._currentScope, annotationNode.valueExpression);
         if (symbol) {
             symbol.addDeclaration({
-                type: 5 /* SpecialBuiltInClass */,
+                type: 7 /* SpecialBuiltInClass */,
                 node: annotationNode,
                 path: this._fileInfo.filePath,
                 range: (0, positionUtils_1.convertOffsetsToRange)(annotationNode.start, textRange_2.TextRange.getEnd(annotationNode), this._fileInfo.lines),
@@ -3087,6 +3202,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._deferredBindingTasks.push({
             scope: this._currentScope,
             codeFlowExpressions: this._currentScopeCodeFlowExpressions,
+            activeTypeParams: new Map(this._activeTypeParams),
             callback,
         });
     }
@@ -3096,6 +3212,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Reset the state
             this._currentScope = nextItem.scope;
             this._currentScopeCodeFlowExpressions = nextItem.codeFlowExpressions;
+            this._activeTypeParams = nextItem.activeTypeParams;
             nextItem.callback();
         }
     }