@zzzen/pyright-internal 1.2.0-dev.20230312 → 1.2.0-dev.20230319

package/dist/analyzer/typeEvaluator.js

@@ -705,11 +705,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if (flags & 65536 /* DisallowRecursiveTypeAliasPlaceholder */) {
-            if ((0, types_1.isTypeVar)(typeResult.type) && (0, typeUtils_1.isTypeAliasPlaceholder)(typeResult.type)) {
-                typeResult.type.details.illegalRecursionDetected = true;
-            }
-        }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
         if (inferenceContext &&
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
@@ -946,7 +941,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getTypeOfAnnotation(paramTypeNode, {
             associateTypeVarsWithScope: true,
             allowTypeVarTuple: paramCategory === 1 /* VarArgList */,
-            disallowRecursiveTypeAlias: true,
             allowUnpackedTypedDict: paramCategory === 2 /* VarArgDictionary */,
             allowUnpackedTuple: paramCategory === 1 /* VarArgList */,
         });
@@ -990,9 +984,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             evaluatorFlags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
         }
-        if (options === null || options === void 0 ? void 0 : options.disallowRecursiveTypeAlias) {
-            evaluatorFlags |= 65536 /* DisallowRecursiveTypeAliasPlaceholder */;
-        }
         if (options === null || options === void 0 ? void 0 : options.allowUnpackedTypedDict) {
             evaluatorFlags |= 8388608 /* AllowUnpackedTypedDict */;
         }
@@ -4548,10 +4539,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // See if the class has a custom metaclass that supports __getitem__, etc.
                 if (concreteSubtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass) &&
-                    !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta'])) {
+                    !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta']) &&
+                    (flags & 128 /* ExpectingType */) === 0) {
                     const itemMethodType = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
                     /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */);
+                    if (flags & 256 /* ExpectingTypeAnnotation */) {
+                        // If the class doesn't derive from Generic, a type argument should not be allowed.
+                        addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeArgsExpectingNone().format({
+                            name: printType(types_1.ClassType.cloneAsInstance(concreteSubtype)),
+                        }), node);
+                    }
                     if (itemMethodType) {
                         return getTypeOfIndexedObjectOrClass(node, concreteSubtype, usage).type;
                     }
@@ -4967,7 +4965,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             adjFlags &= ~(2 /* DoNotSpecialize */ |
                 32 /* DisallowParamSpec */ |
                 64 /* DisallowTypeVarTuple */ |
-                1048576 /* AllowRequired */);
+                1048576 /* AllowRequired */ |
+                16384 /* EnforceTypeVarVarianceConsistency */);
             if (!(options === null || options === void 0 ? void 0 : options.isAnnotatedClass)) {
                 adjFlags |= 131072 /* DisallowClassVar */ | 16 /* DisallowFinal */;
             }
@@ -6548,7 +6547,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         return returnType;
                     }
                     else {
-                        const memberType = (_d = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__')) === null || _d === void 0 ? void 0 : _d.type;
+                        const memberType = (_d = getTypeOfObjectMember(errorNode, expandedSubtype, '__call__', 
+                        /* usage */ undefined, 
+                        /* diag */ undefined, 64 /* SkipAttributeAccessOverride */)) === null || _d === void 0 ? void 0 : _d.type;
                         if (memberType) {
                             const functionResult = validateCallArguments(errorNode, argList, { type: memberType }, typeVarContext, skipUnknownArgCheck, inferenceContext, recursionCount);
                             overloadsUsedForCall.push(...functionResult.overloadsUsedForCall);
@@ -10486,7 +10487,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         !ParseTreeUtils.isNodeContainedWithin(errorNode, firstParamTypeAnnotation)) {
                         const annotationType = getTypeOfAnnotation(firstParamTypeAnnotation, {
                             associateTypeVarsWithScope: true,
-                            disallowRecursiveTypeAlias: true,
                         });
                         if (!(0, types_1.isTypeVar)(annotationType) || !annotationType.details.isSynthesizedSelf) {
                             addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.selfTypeWithTypedSelfOrCls(), errorNode);
@@ -11145,11 +11145,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // can be specialized.
                         typeAliasTypeVar.details.recursiveTypeParameters = (_a = rightHandType.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeParameters;
                     }
-                    if (typeAliasTypeVar.details.illegalRecursionDetected) {
-                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveIndirect().format({
-                            name: typeAliasNameNode.value,
-                        }), node.leftExpression);
-                    }
                 }
             }
         }
@@ -11235,11 +11230,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Set the resulting type to the boundType of the original type alias
         // to support recursive type aliases.
         typeAliasTypeVar.details.boundType = aliasType;
-        if (typeAliasTypeVar.details.illegalRecursionDetected) {
-            addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeAliasIsRecursiveIndirect().format({
-                name: node.name.value,
-            }), node.name);
-        }
         writeTypeCache(node.name, { type: aliasType, isIncomplete }, 0 /* None */);
         return aliasType;
     }
@@ -12437,7 +12427,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             functionType.details.declaredReturnType = types_1.UnknownType.create();
             const returnType = getTypeOfAnnotation(returnTypeAnnotationNode, {
                 associateTypeVarsWithScope: true,
-                disallowRecursiveTypeAlias: true,
             });
             functionType.details.declaredReturnType = returnType;
         }
@@ -13609,7 +13598,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 annotationNode === annotationParent.returnTypeAnnotation) {
                 getTypeOfAnnotation(annotationNode, {
                     associateTypeVarsWithScope: true,
-                    disallowRecursiveTypeAlias: true,
                 });
                 return;
             }
@@ -15085,15 +15073,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (((_a = resolvedDecl.inferredTypeSource) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
                     const baseTypeResult = getTypeOfExpression(resolvedDecl.inferredTypeSource.leftExpression, 2 /* DoNotSpecialize */);
                     const callType = baseTypeResult.type;
-                    if ((0, types_1.isInstantiableClass)(callType) &&
-                        types_1.ClassType.isBuiltIn(callType, [
-                            'TypeVar',
-                            'ParamSpec',
-                            'TypeVarTuple',
-                            'TypedDict',
-                            'NamedTuple',
-                            'NewType',
-                        ])) {
+                    const exemptBuiltins = [
+                        'TypeVar',
+                        'ParamSpec',
+                        'TypeVarTuple',
+                        'TypedDict',
+                        'NamedTuple',
+                        'NewType',
+                    ];
+                    if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, exemptBuiltins)) {
+                        isUnambiguousType = true;
+                    }
+                    else if ((0, types_1.isFunction)(callType) &&
+                        exemptBuiltins.some((name) => callType.details.builtInName === name)) {
                         isUnambiguousType = true;
                     }
                 }
@@ -16783,6 +16775,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
             return true;
         }
+        // Sort the subtypes so we have a deterministic order for unions.
+        let sortedSrcTypes = (0, typeUtils_1.sortTypes)(srcType.subtypes);
         // Handle the case where the source and dest are both unions. Try
         // to eliminate as many exact type matches between the src and dest.
         if ((0, types_1.isUnion)(destType)) {
@@ -16797,8 +16791,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             }
             const remainingDestSubtypes = [];
-            let remainingSrcSubtypes = [...srcType.subtypes];
-            let isIncompatible = false;
+            let remainingSrcSubtypes = sortedSrcTypes;
+            let canUseFastPath = true;
             // First attempt to match all of the non-generic types in the dest
             // to non-generic types in the source.
             destType.subtypes.forEach((destSubtype) => {
@@ -16817,7 +16811,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // For all remaining source subtypes, attempt to find a dest subtype
             // whose primary type matches.
-            (0, typeUtils_1.sortTypes)(remainingSrcSubtypes).forEach((srcSubtype) => {
+            remainingSrcSubtypes.forEach((srcSubtype) => {
                 const destTypeIndex = remainingDestSubtypes.findIndex((destSubtype) => {
                     if ((0, types_1.isClass)(srcSubtype) &&
                         (0, types_1.isClass)(destSubtype) &&
@@ -16834,7 +16828,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
                 if (destTypeIndex >= 0) {
                     if (!assignType(remainingDestSubtypes[destTypeIndex], srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                        isIncompatible = true;
+                        canUseFastPath = false;
                     }
                     remainingDestSubtypes.splice(destTypeIndex, 1);
                     remainingSrcSubtypes = remainingSrcSubtypes.filter((t) => t !== srcSubtype);
@@ -16842,11 +16836,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // If there is are remaining dest subtypes and they're all type variables,
             // attempt to assign the remaining source subtypes to them.
-            if (!isIncompatible && (remainingDestSubtypes.length !== 0 || remainingSrcSubtypes.length !== 0)) {
+            if (canUseFastPath && (remainingDestSubtypes.length !== 0 || remainingSrcSubtypes.length !== 0)) {
                 const isReversed = (flags & 2 /* ReverseTypeVarMatching */) !== 0;
                 const effectiveDestSubtypes = isReversed ? remainingSrcSubtypes : remainingDestSubtypes;
                 if (effectiveDestSubtypes.length === 0 || effectiveDestSubtypes.some((t) => !(0, types_1.isTypeVar)(t))) {
-                    isIncompatible = true;
+                    canUseFastPath = false;
+                    // We can avoid checking the source subtypes that have already been checked.
+                    sortedSrcTypes = remainingSrcSubtypes;
                 }
                 else if (remainingDestSubtypes.length === remainingSrcSubtypes.length) {
                     // If the number of remaining source subtypes is the same as the number
@@ -16854,9 +16850,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     remainingDestSubtypes.forEach((destSubtype, index) => {
                         const srcSubtype = remainingSrcSubtypes[index];
                         if (!assignType(destSubtype, srcSubtype, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                            isIncompatible = true;
+                            canUseFastPath = false;
                         }
                     });
+                    // We can avoid checking the source subtypes that have already been checked.
+                    sortedSrcTypes = remainingSrcSubtypes;
                 }
                 else if (remainingSrcSubtypes.length === 0) {
                     if ((flags & 1024 /* PopulatingExpectedType */) !== 0) {
@@ -16870,24 +16868,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                     // If we've assigned all of the source subtypes but one or more dest
                     // TypeVars have gone unmatched, treat this as success.
-                    return true;
                 }
                 else {
                     // Try to assign a union of the remaining source types to
                     // the first destination TypeVar.
                     if (!assignType(isReversed ? (0, types_1.combineTypes)(remainingDestSubtypes) : remainingDestSubtypes[0], isReversed ? remainingSrcSubtypes[0] : (0, types_1.combineTypes)(remainingSrcSubtypes), diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                        isIncompatible = true;
+                        canUseFastPath = false;
                     }
                 }
             }
-            if (!isIncompatible) {
+            if (canUseFastPath) {
                 return true;
             }
         }
-        // For union sources, all of the types need to be assignable to the dest.
         let isIncompatible = false;
-        // Sort the subtypes so we have a deterministic order for unions.
-        (0, typeUtils_1.doForEachSubtype)(srcType, (subtype, subtypeIndex, allSubtypes) => {
+        sortedSrcTypes.forEach((subtype) => {
             if (isIncompatible) {
                 return;
             }
@@ -16897,11 +16892,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // Determine if the current subtype is subsumed by another subtype
                 // in the same union. If so, we can ignore this.
                 let isSubtypeSubsumed = false;
-                allSubtypes.forEach((innerSubtype, innerSubtypeIndex) => {
-                    if (isSubtypeSubsumed || subtypeIndex === innerSubtypeIndex || (0, types_1.isAnyOrUnknown)(innerSubtype)) {
-                        return;
-                    }
-                    if (isProperSubtype(innerSubtype, concreteSubtype, recursionCount)) {
+                srcType.subtypes.forEach((innerSubtype) => {
+                    if (!isSubtypeSubsumed &&
+                        !(0, types_1.isTypeSame)(innerSubtype, subtype) &&
+                        !(0, types_1.isAnyOrUnknown)(innerSubtype) &&
+                        isProperSubtype(innerSubtype, concreteSubtype, recursionCount)) {
                         isSubtypeSubsumed = true;
                     }
                 });
@@ -16911,8 +16906,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     isIncompatible = true;
                 }
             }
-        }, 
-        /* sortSubtypes */ true);
+        }, /* sortSubtypes */ true);
         if (isIncompatible) {
             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typeAssignmentMismatch().format({
                 sourceType: printType(srcType),