@zzzen/pyright-internal 1.2.0-dev.20230604 → 1.2.0-dev.20230618

package/dist/analyzer/checker.js

@@ -225,6 +225,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (types_1.ClassType.isEnumClass(classTypeResult.classType)) {
                 this._validateEnumClassOverride(node, classTypeResult.classType);
             }
+            this._evaluator.validateInitSubclassArgs(node, classTypeResult.classType);
         }
         this._scopedNodes.push(node);
         return false;
@@ -3737,7 +3738,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             if (overrideFunction) {
-                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, diagAddendum, 
+                if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, 
+                /* baseClass */ undefined, diagAddendum, 
                 /* enforceParamNameMatch */ true)) {
                     const decl = overrideFunction.details.declaration;
                     if (decl && decl.type === 5 /* Function */) {
@@ -3825,6 +3827,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (!mroBaseClass) {
                     continue;
                 }
+                (0, debug_1.assert)((0, types_1.isClass)(mroBaseClass));
                 const baseClassAndSymbol = (0, typeUtils_1.lookUpClassMember)(mroBaseClass, name, 0 /* Default */);
                 if (!baseClassAndSymbol) {
                     continue;
@@ -3944,7 +3947,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Don't check certain magic functions or private symbols.
                 if (!exemptMethods.some((exempt) => exempt === memberName) &&
                     !SymbolNameUtils.isPrivateName(memberName)) {
-                    if (!this._evaluator.validateOverrideMethod(baseType, overrideType, diagAddendum, enforceParamNameMatch)) {
+                    if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
                         const decl = (0, types_1.isFunction)(overrideType) && overrideType.details.declaration
                             ? overrideType.details.declaration
                             : (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
@@ -4041,7 +4044,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             else {
                                 const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(subclassPropMethod), childClassType);
                                 if ((0, types_1.isFunction)(subclassMethodType)) {
-                                    if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, diagAddendum.createAddendum())) {
+                                    if (!this._evaluator.validateOverrideMethod(baseClassMethodType, subclassMethodType, childClassType, diagAddendum.createAddendum())) {
                                         diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.propertyMethodIncompatible().format({
                                             name: methodName,
                                         }));
@@ -4330,6 +4333,12 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isClassInstance)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
             return;
         }
+        // If the method starts with a `*args: P.args`, skip the check.
+        if (paramInfo.category === 1 /* ArgsList */ &&
+            (0, types_1.isParamSpec)(paramInfo.type) &&
+            paramInfo.type.paramSpecAccess === 'args') {
+            return;
+        }
         // Don't enforce this for an overloaded method because the "self" param
         // annotation can be used as a filter for the overload. This differs from
         // mypy, which enforces this check for overloads, but there are legitimate
@@ -4355,38 +4364,50 @@ 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) {
-        let declaredReturnType;
-        let declaredYieldType;
+        var _a;
         const enclosingFunctionNode = ParseTreeUtils.getEnclosingFunction(node);
-        if (enclosingFunctionNode) {
-            const functionTypeResult = this._evaluator.getTypeOfFunction(enclosingFunctionNode);
-            if (functionTypeResult) {
-                (0, debug_1.assert)((0, types_1.isFunction)(functionTypeResult.functionType));
-                declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionTypeResult.functionType);
-                if (declaredReturnType) {
-                    declaredYieldType = (0, typeUtils_1.getGeneratorYieldType)(declaredReturnType, !!enclosingFunctionNode.isAsync);
-                }
-                if (declaredReturnType && !declaredYieldType && enclosingFunctionNode.returnTypeAnnotation) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, enclosingFunctionNode.isAsync
-                        ? localize_1.Localizer.Diagnostic.generatorAsyncReturnType()
-                        : localize_1.Localizer.Diagnostic.generatorSyncReturnType(), enclosingFunctionNode.returnTypeAnnotation);
-                }
-            }
+        if (!enclosingFunctionNode || !enclosingFunctionNode.returnTypeAnnotation) {
+            return;
         }
-        if (this._evaluator.isNodeReachable(node, /* sourceNode */ undefined)) {
-            if (declaredReturnType && (0, types_1.isNever)(declaredReturnType)) {
-                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.noReturnContainsYield(), node);
-            }
-            else if (declaredYieldType) {
-                const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                if (!this._evaluator.assignType(declaredYieldType, yieldType, diagAddendum)) {
-                    this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.yieldTypeMismatch().format({
-                        exprType: this._evaluator.printType(yieldType),
-                        yieldType: this._evaluator.printType(declaredYieldType),
-                    }) + diagAddendum.getString(), node.expression || node);
-                }
-            }
+        const functionTypeResult = this._evaluator.getTypeOfFunction(enclosingFunctionNode);
+        if (!functionTypeResult) {
+            return;
+        }
+        const declaredReturnType = types_1.FunctionType.getSpecializedReturnType(functionTypeResult.functionType);
+        if (!declaredReturnType) {
+            return;
+        }
+        let generatorType;
+        if (!enclosingFunctionNode.isAsync &&
+            (0, types_1.isClassInstance)(declaredReturnType) &&
+            types_1.ClassType.isBuiltIn(declaredReturnType, 'AwaitableGenerator')) {
+            // Handle the old-style (pre-await) generator case
+            // if the return type explicitly uses AwaitableGenerator.
+            generatorType = this._evaluator.getTypingType(node, 'AwaitableGenerator');
+        }
+        else {
+            generatorType = this._evaluator.getTypingType(node, enclosingFunctionNode.isAsync ? 'AsyncGenerator' : 'Generator');
+        }
+        if (!generatorType || !(0, types_1.isInstantiableClass)(generatorType)) {
+            return;
+        }
+        if (!this._evaluator.isNodeReachable(node, /* sourceNode */ undefined)) {
+            return;
+        }
+        if ((0, types_1.isNever)(declaredReturnType)) {
+            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 diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
+            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);
         }
     }
     // Determines whether any of the except statements are unreachable because