@zzzen/pyright-internal 1.2.0-dev.20230806 → 1.2.0-dev.20230820

package/dist/analyzer/checker.js

@@ -47,6 +47,7 @@ const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
 const declaration_1 = require("./declaration");
+const declarationUtils_1 = require("./declarationUtils");
 const importResolver_1 = require("./importResolver");
 const importStatementUtils_1 = require("./importStatementUtils");
 const parameterUtils_1 = require("./parameterUtils");
@@ -211,6 +212,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateBaseClassOverrides(classTypeResult.classType);
                 this._validateSlotsClassVarConflict(classTypeResult.classType);
             }
+            this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
             this._validateConstructorConsistency(classTypeResult.classType);
             this._validateFinalMemberOverrides(classTypeResult.classType);
@@ -339,12 +341,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (param.typeAnnotationComment) {
                 this.walk(param.typeAnnotationComment);
             }
+            // Look for method parameters that are typed with TypeVars that have the wrong variance.
             if (functionTypeResult) {
                 const annotationNode = param.typeAnnotation || param.typeAnnotationComment;
                 if (annotationNode && index < functionTypeResult.functionType.details.parameters.length) {
                     const paramType = functionTypeResult.functionType.details.parameters[index].type;
                     const exemptMethods = ['__init__', '__new__'];
-                    if ((0, types_1.isTypeVar)(paramType) &&
+                    if (containingClassNode &&
+                        (0, types_1.isTypeVar)(paramType) &&
                         paramType.details.declaredVariance === 3 /* Covariant */ &&
                         !paramType.details.isSynthesized &&
                         !exemptMethods.some((name) => name === functionTypeResult.functionType.details.name)) {
@@ -629,6 +633,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         var _a, _b, _c, _d;
         const yieldFromType = this._evaluator.getType(node.expression) || types_1.UnknownType.create();
         let yieldType;
+        let sendType;
         if ((0, types_1.isClassInstance)(yieldFromType) && types_1.ClassType.isBuiltIn(yieldFromType, 'Coroutine')) {
             // Handle the case of old-style (pre-await) coroutines.
             yieldType = types_1.UnknownType.create();
@@ -642,13 +647,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const generatorTypeArgs = (0, typeUtils_1.getGeneratorTypeArgs)(yieldType);
             if (generatorTypeArgs) {
                 yieldType = generatorTypeArgs.length >= 1 ? generatorTypeArgs[0] : types_1.UnknownType.create();
+                sendType = generatorTypeArgs.length >= 2 ? generatorTypeArgs[1] : undefined;
             }
             else {
                 yieldType =
                     (_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);
+        this._validateYieldType(node, yieldType, sendType);
         return true;
     }
     visitRaise(node) {
@@ -957,6 +963,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             });
         }
         else {
+            this._evaluator.evaluateTypesForStatement(node);
             const importInfo = AnalyzerNodeInfo.getImportInfo(node.module);
             if (importInfo &&
                 importInfo.isImportFound &&
@@ -1824,7 +1831,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else if ((0, types_1.isClassInstance)(exceptionType)) {
                 const iterableType = (_b = (_a = this._evaluator.getTypeOfIterator({ type: exceptionType }, /* isAsync */ false, errorNode)) === null || _a === void 0 ? void 0 : _a.type) !== null && _b !== void 0 ? _b : types_1.UnknownType.create();
                 resultingExceptionType = (0, typeUtils_1.mapSubtypes)(iterableType, (subtype) => {
-                    if ((0, types_1.isAnyOrUnknown)(subtype)) {
+                    if ((0, types_1.isAnyOrUnknown)(subtype) || (0, types_1.isNever)(subtype)) {
                         return subtype;
                     }
                     if ((0, types_1.isInstantiableClass)(subtype)) {
@@ -3611,6 +3618,68 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
+    // Verifies that classes that have more than one base class do not have
+    // have conflicting type arguments.
+    _validateMultipleInheritanceBaseClasses(classType, errorNode) {
+        // Skip this check if the class has only one base class or one or more
+        // of the base classes are Any.
+        const filteredBaseClasses = [];
+        for (const baseClass of classType.details.baseClasses) {
+            if (!(0, types_1.isClass)(baseClass)) {
+                return;
+            }
+            if (!types_1.ClassType.isBuiltIn(baseClass, ['Generic', 'Protocol', 'object'])) {
+                filteredBaseClasses.push(baseClass);
+            }
+        }
+        if (filteredBaseClasses.length < 2) {
+            return;
+        }
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        for (const baseClass of filteredBaseClasses) {
+            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            for (const baseClassMroClass of baseClass.details.mro) {
+                // There's no need to check for conflicts if this class isn't generic.
+                if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.details.typeParameters.length > 0) {
+                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, typeVarContext);
+                    // Find the corresponding class in the derived class's MRO list.
+                    const matchingMroClass = classType.details.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, specializedBaseClassMroClass));
+                    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);
+                            if ((0, types_1.isTypeSame)(baseClassObject, baseClassMroObject)) {
+                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.baseClassIncompatible().format({
+                                    baseClass: this._evaluator.printType(baseClassObject),
+                                    type: this._evaluator.printType(matchingMroObject),
+                                }));
+                            }
+                            else {
+                                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.baseClassIncompatibleSubclass().format({
+                                    baseClass: this._evaluator.printType(baseClassObject),
+                                    subclass: this._evaluator.printType(baseClassMroObject),
+                                    type: this._evaluator.printType(matchingMroObject),
+                                }));
+                            }
+                            diagAddendum.addAddendum(diag);
+                            // Break out of the inner loop so we don't report any redundant errors for this base class.
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if (!diagAddendum.isEmpty()) {
+            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.baseClassIncompatible().format({ type: classType.details.name }) +
+                diagAddendum.getString(), errorNode);
+        }
+    }
     // Validates that any methods and variables in multiple base classes are
     // compatible with each other.
     _validateMultipleInheritanceCompatibility(classType, errorNode) {
@@ -3888,6 +3957,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
+        var _a, _b;
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
         }
@@ -4051,7 +4121,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,
-                        }) + diagAddendum.getString(), lastDecl.node);
+                        }) + 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) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
@@ -4093,7 +4163,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
                             className: baseClassAndSymbol.classType.details.name,
-                        }), lastDecl.node);
+                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.path, origDecl.range);
@@ -4336,7 +4406,7 @@ 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) {
+    _validateYieldType(node, yieldType, sendType) {
         var _a;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
         if (!enclosingFunctionNode || !enclosingFunctionNode.returnTypeAnnotation) {
@@ -4371,7 +4441,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsYield(), node);
             return;
         }
-        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, [yieldType], /* isTypeArgumentExplicit */ true));
+        const generatorTypeArgs = [yieldType, sendType !== null && sendType !== void 0 ? sendType : types_1.UnknownType.create(), types_1.UnknownType.create()];
+        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, generatorTypeArgs, /* isTypeArgumentExplicit */ true));
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
             const errorMessage = enclosingFunctionNode.isAsync
@@ -4441,7 +4512,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 });
                 // Were all of the exception types overridden?
-                if (typesOfThisExcept.length === overriddenExceptionCount) {
+                if (typesOfThisExcept.length > 0 && typesOfThisExcept.length === overriddenExceptionCount) {
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.unreachableExcept() + diagAddendum.getString(), except.typeExpression);
                     this._evaluator.addUnreachableCode(except, except.exceptSuite);
                 }