@zzzen/pyright-internal 1.2.0-dev.20230528 → 1.2.0-dev.20230611

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;
@@ -4355,38 +4356,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