@zzzen/pyright-internal 1.2.0-dev.20230917 → 1.2.0-dev.20231001

package/dist/analyzer/checker.d.ts

@@ -82,6 +82,7 @@ export declare class Checker extends ParseTreeWalker {
     private _validateComparisonTypesForIsOperator;
     private _validateComparisonTypes;
     private _isTypeComparable;
+    private _validateGeneratorReturnType;
     private _isTypeValidForUnusedValueTest;
     private _validateFunctionTypeVarUsage;
     private _validateOverloadConsistency;

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) {
@@ -1872,7 +1919,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         for (const paramList of this._typeParameterLists) {
             for (const param of paramList.parameters) {
                 const symbol = AnalyzerNodeInfo.getTypeParameterSymbol(param.name);
-                (0, debug_1.assert)(symbol);
+                if (!symbol) {
+                    // This can happen if the code is unreachable.
+                    return;
+                }
                 if (!accessedSymbolSet.has(symbol.id)) {
                     const decls = symbol.getDeclarations();
                     decls.forEach((decl) => {
@@ -2375,6 +2425,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;
@@ -2491,7 +2542,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
@@ -4126,7 +4177,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     const primaryDecl = decls[0];
                     // Verify that the override type is assignable to (same or narrower than)
                     // the declared type of the base symbol.
-                    const isInvariant = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !primaryDecl.isFinal;
+                    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,