@zzzen/pyright-internal 1.1.255 → 1.2.0-dev.20220703

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;
@@ -617,7 +692,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);
         }
@@ -711,10 +786,17 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._addAntecedent(preForLabel, this._currentFlowNode);
         this._currentFlowNode = preForLabel;
         this._addAntecedent(preElseLabel, this._currentFlowNode);
-        this._createAssignmentTargetFlowNodes(node.targetExpression, /* walkTargets */ true, /* unbound */ false);
+        const targetExpressions = this._trackCodeFlowExpressions(() => {
+            this._createAssignmentTargetFlowNodes(node.targetExpression, /* walkTargets */ true, /* unbound */ false);
+        });
         this._bindLoopStatement(preForLabel, postForLabel, () => {
             this.walk(node.forSuite);
             this._addAntecedent(preForLabel, this._currentFlowNode);
+            // Add any target expressions since they are modified in the loop.
+            targetExpressions.forEach((value) => {
+                var _a;
+                (_a = this._currentScopeCodeFlowExpressions) === null || _a === void 0 ? void 0 : _a.add(value);
+            });
         });
         this._currentFlowNode = this._finishFlowLabel(preElseLabel);
         if (node.elseSuite) {
@@ -787,6 +869,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;
     }
@@ -869,7 +955,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 = {
@@ -1067,7 +1153,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 */);
             }
@@ -1106,16 +1192,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 ||
@@ -1196,14 +1285,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,
@@ -1223,7 +1312,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,
@@ -1233,7 +1322,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                                             isInExceptSuite: this._isInExceptSuite,
                                         };
                                         const aliasDecl = {
-                                            type: 6 /* Alias */,
+                                            type: 8 /* Alias */,
                                             node,
                                             path: resolvedPath,
                                             loadSymbolsFromPath: true,
@@ -1271,7 +1360,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.
@@ -1299,7 +1388,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,
@@ -1318,7 +1407,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                     const aliasDecl = {
-                        type: 6 /* Alias */,
+                        type: 8 /* Alias */,
                         node: importSymbolNode,
                         path: resolvedPath,
                         loadSymbolsFromPath,
@@ -1598,7 +1687,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 = {
@@ -1628,6 +1717,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.
@@ -1693,7 +1794,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 = {
@@ -1724,7 +1825,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
@@ -1741,7 +1842,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);
         }
@@ -1759,7 +1860,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) {
@@ -1774,7 +1875,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         }
         else if (isResolved) {
             newDecl = {
-                type: 6 /* Alias */,
+                type: 8 /* Alias */,
                 node,
                 path: pathOfLastSubmodule,
                 loadSymbolsFromPath: false,
@@ -1790,7 +1891,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,
@@ -2381,7 +2482,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) {
@@ -2429,7 +2537,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 */: {
@@ -2547,7 +2655,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();
                         }
                     }
@@ -2735,7 +2843,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         if (!declarationHandled) {
-            this._addError(localize_1.Localizer.Diagnostic.annotationNotSupported(), typeAnnotation);
+            this._addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.annotationNotSupported(), typeAnnotation);
         }
     }
     // Determines whether the expression refers to a type exported by the typing
@@ -3060,10 +3168,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),
@@ -3080,6 +3188,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
         this._deferredBindingTasks.push({
             scope: this._currentScope,
             codeFlowExpressions: this._currentScopeCodeFlowExpressions,
+            activeTypeParams: new Map(this._activeTypeParams),
             callback,
         });
     }
@@ -3089,6 +3198,7 @@ class Binder extends parseTreeWalker_1.ParseTreeWalker {
             // Reset the state
             this._currentScope = nextItem.scope;
             this._currentScopeCodeFlowExpressions = nextItem.codeFlowExpressions;
+            this._activeTypeParams = nextItem.activeTypeParams;
             nextItem.callback();
         }
     }