@zzzen/pyright-internal 1.2.0-dev.20240818 → 1.2.0-dev.20240901

package/dist/analyzer/typeUtils.d.ts

@@ -107,11 +107,10 @@ export declare function addConditionToType<T extends Type>(type: T, condition: T
 export declare function getTypeCondition(type: Type): TypeCondition[] | undefined;
 export declare function isTypeAliasPlaceholder(type: Type): boolean;
 export declare function isTypeAliasRecursive(typeAliasPlaceholder: TypeVarType, type: Type): boolean | undefined;
-export declare function transformPossibleRecursiveTypeAlias(type: Type): Type;
-export declare function transformPossibleRecursiveTypeAlias(type: Type | undefined): Type | undefined;
+export declare function transformPossibleRecursiveTypeAlias(type: Type, recursionCount?: number): Type;
+export declare function transformPossibleRecursiveTypeAlias(type: Type | undefined, recursionCount?: number): Type | undefined;
 export declare function getTypeVarScopeId(type: Type): TypeVarScopeId | undefined;
 export declare function getTypeVarScopeIds(type: Type): TypeVarScopeId[];
-export declare function specializeWithDefaultTypeArgs(type: ClassType): ClassType;
 export declare function specializeWithUnknownTypeArgs(type: ClassType, tupleClassType?: ClassType): ClassType;
 export declare function getUnknownForTypeVar(typeVar: TypeVarType, tupleClassType?: ClassType): Type;
 export declare function getUnknownForTypeVarTuple(tupleClassType: ClassType): Type;
@@ -120,6 +119,7 @@ export declare function selfSpecializeClass(type: ClassType, options?: SelfSpeci
 export declare function getSpecializedTupleType(type: Type): ClassType | undefined;
 export declare function isLiteralType(type: ClassType): boolean;
 export declare function isLiteralTypeOrUnion(type: Type, allowNone?: boolean): boolean;
+export declare function isLiteralLikeType(type: ClassType): boolean;
 export declare function containsLiteralType(type: Type, includeTypeArgs?: boolean): boolean;
 export declare function getLiteralTypeClassName(type: Type): string | undefined;
 export declare function getUnionSubtypeCount(type: Type): number;
@@ -151,7 +151,7 @@ export declare function getClassIterator(classType: Type, flags?: ClassIteratorF
 export declare function getClassFieldsRecursive(classType: ClassType): Map<string, ClassMember>;
 export declare function addTypeVarsToListIfUnique(list1: TypeVarType[], list2: TypeVarType[], typeVarScopeId?: TypeVarScopeId): void;
 export declare function getTypeVarArgsRecursive(type: Type, recursionCount?: number): TypeVarType[];
-export declare function specializeClassType(type: ClassType): ClassType;
+export declare function specializeWithDefaultTypeArgs(type: ClassType): ClassType;
 export declare function buildSolutionFromSpecializedClass(classType: ClassType): ConstraintSolution;
 export declare function buildSolution(typeParams: TypeVarType[], typeArgs: Type[] | undefined): ConstraintSolution;
 export declare function specializeForBaseClass(srcType: ClassType, baseClass: ClassType): ClassType;

package/dist/analyzer/typeUtils.js

@@ -36,7 +36,6 @@ exports.isTypeAliasRecursive = isTypeAliasRecursive;
 exports.transformPossibleRecursiveTypeAlias = transformPossibleRecursiveTypeAlias;
 exports.getTypeVarScopeId = getTypeVarScopeId;
 exports.getTypeVarScopeIds = getTypeVarScopeIds;
-exports.specializeWithDefaultTypeArgs = specializeWithDefaultTypeArgs;
 exports.specializeWithUnknownTypeArgs = specializeWithUnknownTypeArgs;
 exports.getUnknownForTypeVar = getUnknownForTypeVar;
 exports.getUnknownForTypeVarTuple = getUnknownForTypeVarTuple;
@@ -45,6 +44,7 @@ exports.selfSpecializeClass = selfSpecializeClass;
 exports.getSpecializedTupleType = getSpecializedTupleType;
 exports.isLiteralType = isLiteralType;
 exports.isLiteralTypeOrUnion = isLiteralTypeOrUnion;
+exports.isLiteralLikeType = isLiteralLikeType;
 exports.containsLiteralType = containsLiteralType;
 exports.getLiteralTypeClassName = getLiteralTypeClassName;
 exports.getUnionSubtypeCount = getUnionSubtypeCount;
@@ -76,7 +76,7 @@ exports.getClassIterator = getClassIterator;
 exports.getClassFieldsRecursive = getClassFieldsRecursive;
 exports.addTypeVarsToListIfUnique = addTypeVarsToListIfUnique;
 exports.getTypeVarArgsRecursive = getTypeVarArgsRecursive;
-exports.specializeClassType = specializeClassType;
+exports.specializeWithDefaultTypeArgs = specializeWithDefaultTypeArgs;
 exports.buildSolutionFromSpecializedClass = buildSolutionFromSpecializedClass;
 exports.buildSolution = buildSolution;
 exports.specializeForBaseClass = specializeForBaseClass;
@@ -815,8 +815,12 @@ function isTypeAliasRecursive(typeAliasPlaceholder, type) {
     return ((0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeVar)(subtype) && subtype.shared === typeAliasPlaceholder.shared) !==
         undefined);
 }
-function transformPossibleRecursiveTypeAlias(type) {
+function transformPossibleRecursiveTypeAlias(type, recursionCount = 0) {
     var _a, _b;
+    if (recursionCount >= types_1.maxTypeRecursionCount) {
+        return type;
+    }
+    recursionCount++;
     if (type) {
         const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
         if ((0, types_1.isTypeVar)(type) && ((_b = type.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.name) && type.shared.boundType) {
@@ -824,13 +828,13 @@ function transformPossibleRecursiveTypeAlias(type) {
                 ? convertToInstance(type.shared.boundType)
                 : type.shared.boundType;
             if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArgs) || !type.shared.recursiveAlias.typeParams) {
-                return unspecializedType;
+                return transformPossibleRecursiveTypeAlias(unspecializedType, recursionCount);
             }
             const solution = buildSolution(type.shared.recursiveAlias.typeParams, aliasInfo.typeArgs);
-            return applySolvedTypeVars(unspecializedType, solution);
+            return transformPossibleRecursiveTypeAlias(applySolvedTypeVars(unspecializedType, solution), recursionCount);
         }
         if ((0, types_1.isUnion)(type) && type.priv.includesRecursiveTypeAlias) {
-            let newType = mapSubtypes(type, (subtype) => transformPossibleRecursiveTypeAlias(subtype));
+            let newType = mapSubtypes(type, (subtype) => transformPossibleRecursiveTypeAlias(subtype, recursionCount));
             if (newType !== type && aliasInfo) {
                 // Copy the type alias information if present.
                 newType = types_1.TypeBase.cloneForTypeAlias(newType, aliasInfo);
@@ -867,17 +871,6 @@ function getTypeVarScopeIds(type) {
     }
     return scopeIds;
 }
-// If the class type is generic and does not already have type arguments
-// specified, specialize it with default type arguments (Unknown or the
-// default type if provided).
-function specializeWithDefaultTypeArgs(type) {
-    if (type.shared.typeParams.length === 0 || type.priv.typeArgs) {
-        return type;
-    }
-    return types_1.ClassType.specialize(type, type.shared.typeParams.map((param) => param.shared.defaultType), 
-    /* isTypeArgExplicit */ false, 
-    /* includeSubclasses */ type.priv.includeSubclasses);
-}
 // Specializes the class with "Unknown" type args (or the equivalent for ParamSpecs
 // or TypeVarTuples).
 function specializeWithUnknownTypeArgs(type, tupleClassType) {
@@ -978,6 +971,15 @@ function isLiteralTypeOrUnion(type, allowNone = false) {
     }
     return false;
 }
+function isLiteralLikeType(type) {
+    if (type.priv.literalValue !== undefined) {
+        return true;
+    }
+    if (types_1.ClassType.isBuiltIn(type, 'LiteralString')) {
+        return true;
+    }
+    return false;
+}
 function containsLiteralType(type, includeTypeArgs = false) {
     class ContainsLiteralTypeWalker extends typeWalker_1.TypeWalker {
         constructor(_includeTypeArgs) {
@@ -987,7 +989,7 @@ function containsLiteralType(type, includeTypeArgs = false) {
         }
         visitClass(classType) {
             if ((0, types_1.isClassInstance)(classType)) {
-                if (isLiteralType(classType) || types_1.ClassType.isBuiltIn(classType, 'LiteralString')) {
+                if (isLiteralLikeType(classType)) {
                     this.foundLiteral = true;
                     this.cancelWalk();
                 }
@@ -1594,8 +1596,11 @@ function getTypeVarArgsRecursive(type, recursionCount = 0) {
     return [];
 }
 // Creates a specialized version of the class, filling in any unspecified
-// type arguments with Unknown.
-function specializeClassType(type) {
+// type arguments with Unknown or default value.
+function specializeWithDefaultTypeArgs(type) {
+    if (type.shared.typeParams.length === 0 || type.priv.typeArgs) {
+        return type;
+    }
     const solution = new constraintSolution_1.ConstraintSolution();
     const typeParams = types_1.ClassType.getTypeParams(type);
     typeParams.forEach((typeParam) => {
@@ -2546,7 +2551,7 @@ function convertTypeToParamSpecValue(type) {
         const newFunction = types_1.FunctionType.createInstance('', '', '', type.shared.flags | 65536 /* FunctionTypeFlags.ParamSpecValue */, type.shared.docString);
         newFunction.shared.deprecatedMessage = type.shared.deprecatedMessage;
         type.shared.parameters.forEach((param, index) => {
-            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getParamType(type, index), param.flags, param.name, types_1.FunctionType.getParamDefaultType(type, index)));
+            types_1.FunctionType.addParam(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getParamType(type, index), param.flags, param.name, types_1.FunctionType.getParamDefaultType(type, index), param.defaultExpr));
         });
         newFunction.shared.typeVarScopeId = type.shared.typeVarScopeId;
         newFunction.priv.constructorTypeVarScopeId = type.priv.constructorTypeVarScopeId;
@@ -2985,7 +2990,7 @@ class TypeVarTransformer {
                     if (param.category !== 0 /* ParamCategory.Simple */ || param.name || !swallowPositionOnlySeparator) {
                         types_1.FunctionType.addParam(newFunctionType, types_1.FunctionParam.create(param.category, paramType, param.flags, param.name && types_1.FunctionParam.isNameSynthesized(param)
                             ? `__p${newFunctionType.shared.parameters.length}`
-                            : param.name, types_1.FunctionType.getParamDefaultType(functionType, index)));
+                            : param.name, types_1.FunctionType.getParamDefaultType(functionType, index), param.defaultExpr));
                     }
                 }
             });