@zzzen/pyright-internal 1.2.0-dev.20240421 → 1.2.0-dev.20240505

package/dist/analyzer/checker.js

@@ -397,7 +397,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // This signifies an incomplete stub file that obscures type errors.
         if (this._fileInfo.isStubFile && node.name.value === '__getattr__') {
             const scope = (0, scopeUtils_1.getScopeForNode)(node);
-            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 3 /* ScopeType.Module */) {
+            if ((scope === null || scope === void 0 ? void 0 : scope.type) === 4 /* ScopeType.Module */) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompleteStub, localize_1.LocMessage.stubUsesGetAttr(), node.name);
             }
         }
@@ -741,9 +741,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if ((0, types_1.isClassInstance)(annotationType) && types_1.ClassType.isBuiltIn(annotationType, 'TypeAlias')) {
                 const scope = (0, scopeUtils_1.getScopeForNode)(node);
                 if (scope) {
-                    if (scope.type !== 2 /* ScopeType.Class */ &&
-                        scope.type !== 3 /* ScopeType.Module */ &&
-                        scope.type !== 4 /* ScopeType.Builtin */) {
+                    if (scope.type !== 3 /* ScopeType.Class */ &&
+                        scope.type !== 4 /* ScopeType.Module */ &&
+                        scope.type !== 5 /* ScopeType.Builtin */) {
                         this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasNotInModuleOrClass(), node.leftExpression.typeAnnotation);
                     }
                 }
@@ -767,31 +767,37 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (baseType) {
             (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(subtype);
-                if ((0, types_1.isClassInstance)(subtype) &&
-                    (tupleType === null || tupleType === void 0 ? void 0 : tupleType.tupleTypeArguments) &&
-                    !(0, typeUtils_1.isUnboundedTupleClass)(tupleType) &&
-                    !this._evaluator.isTypeSubsumedByOtherType(tupleType, baseType, /* allowAnyToSubsume */ false)) {
-                    const tupleLength = tupleType.tupleTypeArguments.length;
-                    if (node.items.length === 1 &&
-                        !node.trailingComma &&
-                        node.items[0].argumentCategory === 0 /* ArgumentCategory.Simple */ &&
-                        !node.items[0].name) {
-                        const subscriptType = this._evaluator.getType(node.items[0].valueExpression);
-                        if (subscriptType &&
-                            (0, types_1.isClassInstance)(subscriptType) &&
-                            types_1.ClassType.isBuiltIn(subscriptType, 'int') &&
-                            (0, typeUtils_1.isLiteralType)(subscriptType) &&
-                            typeof subscriptType.literalValue === 'number') {
-                            if ((subscriptType.literalValue >= 0 && subscriptType.literalValue >= tupleLength) ||
-                                (subscriptType.literalValue < 0 && subscriptType.literalValue + tupleLength < 0)) {
-                                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleIndexOutOfRange().format({
-                                    index: subscriptType.literalValue,
-                                    type: this._evaluator.printType(subtype),
-                                }), node);
-                            }
-                        }
-                    }
+                if (!(0, types_1.isClassInstance)(subtype) || !(tupleType === null || tupleType === void 0 ? void 0 : tupleType.tupleTypeArguments) || (0, typeUtils_1.isUnboundedTupleClass)(tupleType)) {
+                    return;
+                }
+                const tupleLength = tupleType.tupleTypeArguments.length;
+                if (node.items.length !== 1 ||
+                    node.trailingComma ||
+                    node.items[0].argumentCategory !== 0 /* ArgumentCategory.Simple */ ||
+                    node.items[0].name) {
+                    return;
+                }
+                const subscriptType = this._evaluator.getType(node.items[0].valueExpression);
+                if (!subscriptType ||
+                    !(0, types_1.isClassInstance)(subscriptType) ||
+                    !types_1.ClassType.isBuiltIn(subscriptType, 'int') ||
+                    !(0, typeUtils_1.isLiteralType)(subscriptType) ||
+                    typeof subscriptType.literalValue !== 'number') {
+                    return;
                 }
+                if ((subscriptType.literalValue < 0 || subscriptType.literalValue < tupleLength) &&
+                    (subscriptType.literalValue >= 0 || subscriptType.literalValue + tupleLength >= 0)) {
+                    return;
+                }
+                // This can be an expensive check, so we save it for the end once we
+                // are about to emit a diagnostic.
+                if (this._evaluator.isTypeSubsumedByOtherType(tupleType, baseType, /* allowAnyToSubsume */ false)) {
+                    return;
+                }
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.tupleIndexOutOfRange().format({
+                    index: subscriptType.literalValue,
+                    type: this._evaluator.printType(subtype),
+                }), node);
             });
         }
         return true;
@@ -1043,12 +1049,41 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitTypeParameter(node) {
+        var _a, _b, _c, _d;
+        // Verify that there are no live type variables with the same
+        // name in outer scopes.
+        let curNode = (_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent;
+        let foundDuplicate = false;
+        while (curNode) {
+            const typeVarScopeNode = ParseTreeUtils.getTypeVarScopeNode(curNode);
+            if (!typeVarScopeNode) {
+                break;
+            }
+            if (typeVarScopeNode.nodeType === 10 /* ParseNodeType.Class */) {
+                const classType = (_c = this._evaluator.getTypeOfClass(typeVarScopeNode)) === null || _c === void 0 ? void 0 : _c.classType;
+                if (classType === null || classType === void 0 ? void 0 : classType.details.typeParameters.some((param) => param.details.name === node.name.value)) {
+                    foundDuplicate = true;
+                    break;
+                }
+            }
+            else if (typeVarScopeNode.nodeType === 28 /* ParseNodeType.Function */) {
+                const functionType = (_d = this._evaluator.getTypeOfFunction(typeVarScopeNode)) === null || _d === void 0 ? void 0 : _d.functionType;
+                if (functionType === null || functionType === void 0 ? void 0 : functionType.details.typeParameters.some((param) => param.details.name === node.name.value)) {
+                    foundDuplicate = true;
+                    break;
+                }
+            }
+            curNode = typeVarScopeNode.parent;
+        }
+        if (foundDuplicate) {
+            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeVarUsedByOuterScope().format({ name: node.name.value }), node.name);
+        }
         return false;
     }
     visitTypeAlias(node) {
         const scope = (0, scopeUtils_1.getScopeForNode)(node);
         if (scope) {
-            if (scope.type !== 2 /* ScopeType.Class */ && scope.type !== 3 /* ScopeType.Module */ && scope.type !== 4 /* ScopeType.Builtin */) {
+            if (scope.type !== 3 /* ScopeType.Class */ && scope.type !== 4 /* ScopeType.Module */ && scope.type !== 5 /* ScopeType.Builtin */) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasStatementBadScope(), node.name);
             }
         }
@@ -2010,8 +2045,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // Report unaccessed type parameters.
         const accessedSymbolSet = this._fileInfo.accessedSymbolSet;
         for (const paramList of this._typeParameterLists) {
+            const typeParamScope = AnalyzerNodeInfo.getScope(paramList);
             for (const param of paramList.parameters) {
-                const symbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
+                const symbol = typeParamScope === null || typeParamScope === void 0 ? void 0 : typeParamScope.symbolTable.get(param.name.value);
                 if (!symbol) {
                     // This can happen if the code is unreachable.
                     return;
@@ -2123,11 +2159,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (decl.type === 1 /* DeclarationType.Variable */) {
                 if (decl.inferredTypeSource) {
                     if (sawAssignment) {
-                        // We check for assignment of Final instance and class variables
-                        // the type evaluator because we need to take into account whether
-                        // the assignment is within an `__init__` method, so ignore class
-                        // scopes here.
-                        if (scopeType !== 2 /* ScopeType.Class */) {
+                        let exemptAssignment = false;
+                        if (scopeType === 3 /* ScopeType.Class */) {
+                            // We check for assignment of Final instance and class variables
+                            // in the type evaluator because we need to take into account whether
+                            // the assignment is within an `__init__` method, so ignore class
+                            // scopes here.
+                            const classOrFunc = ParseTreeUtils.getEnclosingClassOrFunction(decl.node);
+                            if ((classOrFunc === null || classOrFunc === void 0 ? void 0 : classOrFunc.nodeType) === 28 /* ParseNodeType.Function */) {
+                                exemptAssignment = true;
+                            }
+                        }
+                        if (!exemptAssignment) {
                             reportRedeclaration = true;
                         }
                     }
@@ -2856,7 +2899,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _isSymbolPrivate(nameValue, scopeType) {
         // All variables within the scope of a function or a list
         // comprehension are considered private.
-        if (scopeType === 1 /* ScopeType.Function */ || scopeType === 0 /* ScopeType.ListComprehension */) {
+        if (scopeType === 2 /* ScopeType.Function */ || scopeType === 1 /* ScopeType.ListComprehension */) {
             return true;
         }
         // See if the symbol is private.
@@ -2865,7 +2908,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (SymbolNameUtils.isProtectedName(nameValue)) {
             // Protected names outside of a class scope are considered private.
-            const isClassScope = scopeType === 2 /* ScopeType.Class */;
+            const isClassScope = scopeType === 3 /* ScopeType.Class */;
             return !isClassScope;
         }
         return false;
@@ -2959,6 +3002,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 name: type.details.name,
                             });
                         }
+                        else if ((0, types_1.isClassInstance)(type) && overload.details.name === '__call__') {
+                            deprecatedMessage = overload.details.deprecatedMessage;
+                            errorMessage = localize_1.LocMessage.deprecatedFunction().format({
+                                name: node.value,
+                            });
+                        }
                     }
                 });
             }
@@ -2970,15 +3019,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     node.value === subtype.details.name) {
                     deprecatedMessage = subtype.details.deprecatedMessage;
                     errorMessage = localize_1.LocMessage.deprecatedClass().format({ name: subtype.details.name });
+                    return;
                 }
-                else {
-                    // See if this is part of a call to a constructor.
-                    getDeprecatedMessageForOverloadedCall(this._evaluator, subtype);
-                }
+                getDeprecatedMessageForOverloadedCall(this._evaluator, subtype);
+                return;
             }
-            else if ((0, types_1.isFunction)(subtype)) {
+            if ((0, types_1.isFunction)(subtype)) {
                 if (subtype.details.deprecatedMessage !== undefined) {
-                    if (!subtype.details.name || node.value === subtype.details.name) {
+                    if (!subtype.details.name ||
+                        subtype.details.name === '__call__' ||
+                        node.value === subtype.details.name) {
                         deprecatedMessage = subtype.details.deprecatedMessage;
                         errorMessage = getDeprecatedMessageForFunction(subtype);
                     }
@@ -4742,7 +4792,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             isClassVar = true;
                         }
                     }
-                    if (isBaseClassVar !== isClassVar) {
+                    // Allow TypedDict members to have the same name as class variables in the
+                    // base class because TypedDict members are not really instance members.
+                    const ignoreTypedDictOverride = types_1.ClassType.isTypedDictClass(childClassType) && !isClassVar;
+                    if (isBaseClassVar !== isClassVar && !ignoreTypedDictOverride) {
                         const unformattedMessage = overrideSymbol.isClassVar()
                             ? localize_1.LocMessage.classVarOverridesInstanceVar()
                             : localize_1.LocMessage.instanceVarOverridesClassVar();
@@ -4932,7 +4985,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (functionType.details.name === '__init__' && functionType.details.methodClass) {
             const typeVars = (0, typeUtils_1.getTypeVarArgumentsRecursive)(paramInfo.type);
             if (typeVars.some((typeVar) => { var _a; return typeVar.scopeId === ((_a = functionType.details.methodClass) === null || _a === void 0 ? void 0 : _a.details.typeVarScopeId); })) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramInfo.typeAnnotation);
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramInfo.typeAnnotation);
             }
         }
         // If this is a protocol class, the self and cls parameters can be bound