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

package/dist/analyzer/checker.js

@@ -168,14 +168,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // have the proper variance.
                 this._validateProtocolTypeParamVariance(node, classTypeResult.classType);
             }
-            // Skip the overrides check for stub files. Many of the built-in
-            // typeshed stub files trigger this diagnostic. Also skip the slots
-            // check because class variables declared in a stub file are
-            // interpreted as instance variables.
+            // Skip the slots check because class variables declared in a stub
+            // file are interpreted as instance variables.
             if (!this._fileInfo.isStubFile) {
-                this._validateBaseClassOverrides(classTypeResult.classType);
                 this._validateSlotsClassVarConflict(classTypeResult.classType);
             }
+            this._validateBaseClassOverrides(classTypeResult.classType);
             this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
             this._validateConstructorConsistency(classTypeResult.classType);
@@ -590,8 +588,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitYield(node) {
-        const yieldType = node.expression ? this._evaluator.getType(node.expression) : types_1.NoneType.createInstance();
-        this._validateYieldType(node, yieldType || types_1.UnknownType.create());
+        var _a;
+        const yieldTypeResult = node.expression
+            ? this._evaluator.getTypeResult(node.expression)
+            : { type: types_1.NoneType.createInstance() };
+        this._validateYieldType(node, (_a = yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.type) !== null && _a !== void 0 ? _a : types_1.UnknownType.create(), yieldTypeResult === null || yieldTypeResult === void 0 ? void 0 : yieldTypeResult.expectedTypeDiagAddendum);
         return true;
     }
     visitYieldFrom(node) {
@@ -619,7 +620,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     (_d = (_c = this._evaluator.getTypeOfIterator({ type: yieldFromType }, /* isAsync */ false, node)) === null || _c === void 0 ? void 0 : _c.type) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
             }
         }
-        this._validateYieldType(node, yieldType, sendType);
+        this._validateYieldType(node, yieldType, /* expectedDiagAddendum */ undefined, sendType);
         return true;
     }
     visitRaise(node) {
@@ -2645,12 +2646,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     break;
                 case 3 /* None */:
-                    if (!isInstanceCheck) {
-                        isSupported = false;
-                    }
-                    else {
-                        isSupported = types_1.TypeBase.isInstantiable(subtype);
-                    }
+                    isSupported = types_1.TypeBase.isInstantiable(subtype);
                     break;
                 case 5 /* Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
@@ -3634,8 +3630,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         newMemberType = this._evaluator.bindFunctionToClassOrObject(classType, newMemberType, 
         /* memberClass */ undefined, 
-        /* errorNode */ undefined, 
-        /* recursionCount */ undefined, 
         /* treatConstructorAsClassMember */ true);
         if (!newMemberType) {
             return;
@@ -3745,10 +3739,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (matchingMroClass && (0, types_1.isInstantiableClass)(matchingMroClass)) {
                         const matchingMroObject = types_1.ClassType.cloneAsInstance(matchingMroClass);
                         const baseClassMroObject = types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass);
-                        // If the types match exactly, we can shortcut the remainder of the MRO chain.
-                        // if (isTypeSame(matchingMroObject, baseClassMroObject)) {
-                        //     break;
-                        // }
                         if (!this._evaluator.assignType(matchingMroObject, baseClassMroObject)) {
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             const baseClassObject = (0, typeUtils_1.convertToInstance)(baseClass);
@@ -4073,7 +4063,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (memberName === '_') {
             return;
         }
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClassAndSymbol.classType);
+        const baseClass = baseClassAndSymbol.classType;
+        const childClassSelf = (0, typeUtils_1.selfSpecializeClass)(childClassType);
+        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, types_1.ClassType.cloneAsInstance(childClassSelf));
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloadedFunction)(overrideType)) {
@@ -4083,8 +4075,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // false positives.
                 const enforceParamNameMatch = !SymbolNameUtils.isDunderName(memberName);
                 // Don't check certain magic functions or private symbols.
+                // Also, skip this check if the class is a TypedDict. The methods for a TypedDict
+                // are synthesized, and they can result in many overloads. We assume they
+                // are correct and will not produce any errors.
                 if (!exemptMethods.some((exempt) => exempt === memberName) &&
-                    !SymbolNameUtils.isPrivateName(memberName)) {
+                    !SymbolNameUtils.isPrivateName(memberName) &&
+                    !types_1.ClassType.isTypedDictClass(childClassType)) {
                     if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
                         const decl = (0, types_1.isFunction)(overrideType) && overrideType.details.declaration
                             ? overrideType.details.declaration
@@ -4092,7 +4088,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (decl) {
                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
                                 name: memberName,
-                                className: baseClassAndSymbol.classType.details.name,
+                                className: baseClass.details.name,
                             }) + diagAddendum.getString(), decl.type === 5 /* Function */ ? decl.node.name : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
@@ -4108,7 +4104,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         if (decl && decl.type === 5 /* Function */) {
                             const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
                                 name: memberName,
-                                className: baseClassAndSymbol.classType.details.name,
+                                className: baseClass.details.name,
                             }), decl.node.name);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
@@ -4122,13 +4118,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Special-case overrides of methods in '_TypedDict', since
                 // TypedDict attributes aren't manifest as attributes but rather
                 // as named keys.
-                if (!types_1.ClassType.isBuiltIn(baseClassAndSymbol.classType, '_TypedDict')) {
+                if (!types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
                     const decls = overrideSymbol.getDeclarations();
                     if (decls.length > 0) {
                         const lastDecl = decls[decls.length - 1];
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.methodOverridden().format({
                             name: memberName,
-                            className: baseClassAndSymbol.classType.details.name,
+                            className: baseClass.details.name,
                             type: this._evaluator.printType(overrideType),
                         }), lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
@@ -4146,14 +4142,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (decls.length > 0) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
                         name: memberName,
-                        className: baseClassAndSymbol.classType.details.name,
+                        className: baseClass.details.name,
                     }), decls[decls.length - 1].node);
                 }
             }
             else {
                 const basePropFields = baseType.details.fields;
                 const subclassPropFields = overrideType.details.fields;
-                const baseClassType = baseClassAndSymbol.classType;
+                const baseClassType = baseClass;
                 ['fget', 'fset', 'fdel'].forEach((methodName) => {
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     const baseClassPropMethod = basePropFields.get(methodName);
@@ -4218,9 +4214,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     let isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !primaryDecl.isFinal;
                     // If the entry is a member of a frozen dataclass, it is immutable,
                     // so it does not need to be invariant.
-                    if (types_1.ClassType.isFrozenDataClass(baseClassAndSymbol.classType) &&
-                        baseClassAndSymbol.classType.details.dataClassEntries) {
-                        const dataclassEntry = baseClassAndSymbol.classType.details.dataClassEntries.find((entry) => entry.name === memberName);
+                    if (types_1.ClassType.isFrozenDataClass(baseClass) && baseClass.details.dataClassEntries) {
+                        const dataclassEntry = baseClass.details.dataClassEntries.find((entry) => entry.name === memberName);
                         if (dataclassEntry) {
                             isInvariant = false;
                         }
@@ -4239,7 +4234,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.symbolOverridden().format({
                             name: memberName,
-                            className: baseClassAndSymbol.classType.details.name,
+                            className: baseClass.details.name,
                         }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
@@ -4252,7 +4247,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (!isBaseVarFinal && overrideFinalVarDecl) {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.variableFinalOverride().format({
                             name: memberName,
-                            className: baseClassAndSymbol.classType.details.name,
+                            className: baseClass.details.name,
                         }), lastDecl.node);
                         if (diag) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), overrideFinalVarDecl.path, overrideFinalVarDecl.range);
@@ -4281,7 +4276,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             : localize_1.Localizer.Diagnostic.instanceVarOverridesClassVar();
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
-                            className: baseClassAndSymbol.classType.details.name,
+                            className: baseClass.details.name,
                         }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
@@ -4525,8 +4520,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     }
     // Determines whether a yield or yield from node is compatible with the
     // return type annotation of the containing function.
-    _validateYieldType(node, yieldType, sendType) {
-        var _a;
+    _validateYieldType(node, yieldType, expectedDiagAddendum, sendType) {
+        var _a, _b, _c, _d;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         if (!enclosingFunctionNode || !enclosingFunctionNode.returnTypeAnnotation) {
             return;
@@ -4567,7 +4562,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const errorMessage = enclosingFunctionNode.isAsync
                 ? localize_1.Localizer.Diagnostic.generatorAsyncReturnType()
                 : localize_1.Localizer.Diagnostic.generatorSyncReturnType();
-            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, errorMessage.format({ yieldType: this._evaluator.printType(yieldType) }) + diagAddendum.getString(), (_a = node.expression) !== null && _a !== void 0 ? _a : node);
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, errorMessage.format({ yieldType: this._evaluator.printType(yieldType) }) +
+                ((_a = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getString()) !== null && _a !== void 0 ? _a : diagAddendum.getString()), (_b = node.expression) !== null && _b !== void 0 ? _b : node, (_d = (_c = expectedDiagAddendum === null || expectedDiagAddendum === void 0 ? void 0 : expectedDiagAddendum.getEffectiveTextRange()) !== null && _c !== void 0 ? _c : node.expression) !== null && _d !== void 0 ? _d : node);
         }
     }
     // Determines whether any of the except statements are unreachable because