@zzzen/pyright-internal 1.2.0-dev.20230910 → 1.2.0-dev.20230924

package/dist/analyzer/checker.js

@@ -358,6 +358,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Verify TypeGuard functions.
             this._validateTypeGuardFunction(node, functionTypeResult.functionType, containingClassNode !== undefined);
             this._validateFunctionTypeVarUsage(node, functionTypeResult);
+            this._validateGeneratorReturnType(node, functionTypeResult.functionType);
         }
         // If we're at the module level within a stub file, report a diagnostic
         // if there is a '__getattr__' function defined when in strict mode.
@@ -723,7 +724,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const baseType = this._evaluator.getType(node.baseExpression);
         if (baseType) {
             (0, typeUtils_1.doForEachSubtype)(baseType, (subtype) => {
-                if ((0, types_1.isClassInstance)(subtype) && subtype.tupleTypeArguments && !(0, typeUtils_1.isUnboundedTupleClass)(subtype)) {
+                if ((0, types_1.isClassInstance)(subtype) &&
+                    subtype.tupleTypeArguments &&
+                    !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
+                    !this._evaluator.isTypeSubsumedByOtherType(subtype, baseType, /* allowAnyToSubsume */ false)) {
                     const tupleLength = subtype.tupleTypeArguments.length;
                     if (node.items.length === 1 &&
                         !node.trailingComma &&
@@ -1412,6 +1416,49 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return true;
     }
+    // If the function is a generator, validates that its annotated return type
+    // is appropriate for a generator.
+    _validateGeneratorReturnType(node, functionType) {
+        var _a;
+        if (!types_1.FunctionType.isGenerator(functionType)) {
+            return;
+        }
+        const declaredReturnType = functionType.details.declaredReturnType;
+        if (!declaredReturnType) {
+            return;
+        }
+        if ((0, types_1.isNever)(declaredReturnType)) {
+            return;
+        }
+        const functionDecl = functionType.details.declaration;
+        if (!functionDecl || !functionDecl.yieldStatements || functionDecl.yieldStatements.length === 0) {
+            return;
+        }
+        let generatorType;
+        if (!node.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, node.isAsync ? 'AsyncGenerator' : 'Generator');
+        }
+        if (!generatorType || !(0, types_1.isInstantiableClass)(generatorType)) {
+            return;
+        }
+        const specializedGenerator = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, [types_1.AnyType.create(), types_1.AnyType.create(), types_1.AnyType.create()], 
+        /* isTypeArgumentExplicit */ true));
+        const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+        if (!this._evaluator.assignType(declaredReturnType, specializedGenerator, diagAddendum)) {
+            const errorMessage = node.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(types_1.AnyType.create()) }) +
+                diagAddendum.getString(), (_a = node.returnTypeAnnotation) !== null && _a !== void 0 ? _a : node.name);
+        }
+    }
     // Determines whether the specified type is one that should trigger
     // an "unused" value diagnostic.
     _isTypeValidForUnusedValueTest(type) {
@@ -1897,14 +1944,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     // There should never be a single overload.
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.singleOverload().format({ name }), primaryDecl.node.name);
                 }
-                overloadedFunctions.forEach((overload) => {
-                    if (overload.details.declaration &&
-                        !ParseTreeUtils.isFunctionSuiteEmpty(overload.details.declaration.node)) {
-                        const diag = new diagnostic_1.DiagnosticAddendum();
-                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overloadWithImplementation());
-                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadWithImplementation().format({ name }) + diag.getString(), overload.details.declaration.node.name);
-                    }
-                });
                 // If the file is not a stub and this is the first overload,
                 // verify that there is an implementation.
                 if (!this._fileInfo.isStubFile && overloadedFunctions.length > 0) {
@@ -2383,6 +2422,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         arg0Type = (0, typeUtils_1.mapSubtypes)(arg0Type, (subtype) => {
             return (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(subtype);
         });
+        arg0Type = this._evaluator.expandPromotionTypes(node, arg0Type);
         const arg1Type = this._evaluator.getType(node.arguments[1].valueExpression);
         if (!arg1Type) {
             return;
@@ -2499,7 +2539,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const filteredTypes = [];
             for (const filterType of classTypeList) {
                 const filterIsSuperclass = (0, typeGuards_1.isIsinstanceFilterSuperclass)(this._evaluator, varType, filterType, filterType, isInstanceCheck);
-                const filterIsSubclass = (0, typeGuards_1.isIsinstanceFilterSubclass)(this._evaluator, varType, filterType, filterType, isInstanceCheck);
+                const filterIsSubclass = (0, typeGuards_1.isIsinstanceFilterSubclass)(this._evaluator, varType, filterType, isInstanceCheck);
                 // Normally, a class should never be both a subclass and a
                 // superclass. However, this can happen if one of the classes
                 // derives from an unknown type. In this case, we'll add an
@@ -2662,27 +2702,34 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // we can determine which overload(s) were used to satisfy
             // the call expression and determine whether any of them
             // are deprecated.
+            let callTypeResult;
             const callNode = ParseTreeUtils.getCallForName(node);
             if (callNode) {
-                const callTypeResult = evaluator.getTypeResult(callNode);
-                if (callTypeResult &&
-                    callTypeResult.overloadsUsedForCall &&
-                    callTypeResult.overloadsUsedForCall.length > 0) {
-                    callTypeResult.overloadsUsedForCall.forEach((overload) => {
-                        if (overload.details.deprecatedMessage !== undefined) {
-                            if (node.value === overload.details.name) {
-                                deprecatedMessage = overload.details.deprecatedMessage;
-                                errorMessage = getDeprecatedMessageForFunction(overload);
-                            }
-                            else if ((0, types_1.isInstantiableClass)(type) && overload.details.name === '__init__') {
-                                deprecatedMessage = overload.details.deprecatedMessage;
-                                errorMessage = localize_1.Localizer.Diagnostic.deprecatedConstructor().format({
-                                    name: type.details.name,
-                                });
-                            }
+                callTypeResult = evaluator.getTypeResult(callNode);
+            }
+            else {
+                const decoratorNode = ParseTreeUtils.getDecoratorForName(node);
+                if (decoratorNode) {
+                    callTypeResult = evaluator.getTypeResultForDecorator(decoratorNode);
+                }
+            }
+            if (callTypeResult &&
+                callTypeResult.overloadsUsedForCall &&
+                callTypeResult.overloadsUsedForCall.length > 0) {
+                callTypeResult.overloadsUsedForCall.forEach((overload) => {
+                    if (overload.details.deprecatedMessage !== undefined) {
+                        if (node.value === overload.details.name) {
+                            deprecatedMessage = overload.details.deprecatedMessage;
+                            errorMessage = getDeprecatedMessageForFunction(overload);
                         }
-                    });
-                }
+                        else if ((0, types_1.isInstantiableClass)(type) && overload.details.name === '__init__') {
+                            deprecatedMessage = overload.details.deprecatedMessage;
+                            errorMessage = localize_1.Localizer.Diagnostic.deprecatedConstructor().format({
+                                name: type.details.name,
+                            });
+                        }
+                    }
+                });
             }
         }
         (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
@@ -2699,9 +2746,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             else if ((0, types_1.isFunction)(subtype)) {
-                if (subtype.details.deprecatedMessage !== undefined && node.value === subtype.details.name) {
-                    deprecatedMessage = subtype.details.deprecatedMessage;
-                    errorMessage = getDeprecatedMessageForFunction(subtype);
+                if (subtype.details.deprecatedMessage !== undefined) {
+                    if (!subtype.details.name || node.value === subtype.details.name) {
+                        deprecatedMessage = subtype.details.deprecatedMessage;
+                        errorMessage = getDeprecatedMessageForFunction(subtype);
+                    }
                 }
             }
             else if ((0, types_1.isOverloadedFunction)(subtype)) {
@@ -4122,10 +4171,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 const decls = overrideSymbol.getDeclarations();
                 if (decls.length > 0) {
                     const lastDecl = decls[decls.length - 1];
+                    const primaryDecl = decls[0];
                     // Verify that the override type is assignable to (same or narrower than)
                     // the declared type of the base symbol.
-                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                    if (!this._evaluator.assignType(baseType, overrideType, diagAddendum)) {
+                    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 (dataclassEntry) {
+                            isInvariant = false;
+                        }
+                    }
+                    let diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
+                    /* destTypeVarContext */ undefined, 
+                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* EnforceInvariance */ : 0 /* Default */)) {
+                        if (isInvariant) {
+                            diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                            diagAddendum.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideIsInvariant());
+                            diagAddendum.createAddendum().addMessage(localize_1.Localizer.DiagnosticAddendum.overrideInvariantMismatch().format({
+                                overrideType: this._evaluator.printType(overrideType),
+                                baseType: this._evaluator.printType(baseType),
+                            }));
+                        }
                         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,