@zzzen/pyright-internal 1.2.0-dev.20230730 → 1.2.0-dev.20230813

package/dist/analyzer/typeUtils.js

@@ -109,7 +109,17 @@ var AssignTypeFlags;
 // each other.
 class UniqueSignatureTracker {
     constructor() {
-        this._signaturesSeen = [];
+        this._trackedSignatures = [];
+    }
+    getTrackedSignatures() {
+        return this._trackedSignatures;
+    }
+    addTrackedSignatures(signatures) {
+        signatures.forEach((s) => {
+            s.expressionOffsets.forEach((offset) => {
+                this.addSignature(s.type, offset);
+            });
+        });
     }
     findSignature(signature) {
         // Use the associated overload type if this is a function associated with an overload.
@@ -117,7 +127,7 @@ class UniqueSignatureTracker {
         if ((0, types_1.isFunction)(signature) && signature.overloaded) {
             effectiveSignature = signature.overloaded;
         }
-        return this._signaturesSeen.find((s) => {
+        return this._trackedSignatures.find((s) => {
             return (0, types_1.isTypeSame)(effectiveSignature, s.type);
         });
     }
@@ -132,7 +142,7 @@ class UniqueSignatureTracker {
             }
         }
         else {
-            this._signaturesSeen.push({ type: effectiveSignature, expressionOffsets: [offset] });
+            this._trackedSignatures.push({ type: effectiveSignature, expressionOffsets: [offset] });
         }
     }
 }
@@ -186,35 +196,35 @@ function makeInferenceContext(expectedType, isTypeIncomplete, signatureTracker)
 }
 exports.makeInferenceContext = makeInferenceContext;
 // Calls a callback for each subtype and combines the results
-// into a final type.
+// into a final type. It performs no memory allocations if the
+// transformed type is the same as the original.
 function mapSubtypes(type, callback) {
     if ((0, types_1.isUnion)(type)) {
-        const newSubtypes = [];
-        let typeChanged = false;
-        type.subtypes.forEach((subtype) => {
+        for (let i = 0; i < type.subtypes.length; i++) {
+            const subtype = type.subtypes[i];
             const transformedType = callback(subtype);
-            if (transformedType) {
-                if (transformedType !== subtype) {
-                    newSubtypes.push(addConditionToType(transformedType, getTypeCondition(type)));
-                    typeChanged = true;
+            // Avoid doing any memory allocations until a change is detected.
+            if (subtype !== transformedType) {
+                const typesToCombine = type.subtypes.slice(0, i);
+                // Create a helper lambda that accumulates transformed subtypes.
+                const accumulateSubtype = (newSubtype) => {
+                    if (newSubtype) {
+                        typesToCombine.push(addConditionToType(newSubtype, getTypeCondition(type)));
+                    }
+                };
+                accumulateSubtype(transformedType);
+                for (i++; i < type.subtypes.length; i++) {
+                    accumulateSubtype(callback(type.subtypes[i]));
                 }
-                else {
-                    newSubtypes.push(subtype);
+                const newType = (0, types_1.combineTypes)(typesToCombine);
+                // Do our best to retain type aliases.
+                if (newType.category === 9 /* Union */) {
+                    types_1.UnionType.addTypeAliasSource(newType, type);
                 }
+                return newType;
             }
-            else {
-                typeChanged = true;
-            }
-        });
-        if (!typeChanged) {
-            return type;
-        }
-        const newType = (0, types_1.combineTypes)(newSubtypes);
-        // Do our best to retain type aliases.
-        if (newType.category === 9 /* Union */) {
-            types_1.UnionType.addTypeAliasSource(newType, type);
         }
-        return newType;
+        return type;
     }
     const transformedSubtype = callback(type);
     if (!transformedSubtype) {
@@ -519,7 +529,7 @@ function transformPossibleRecursiveTypeAlias(type) {
             let newType = mapSubtypes(type, (subtype) => transformPossibleRecursiveTypeAlias(subtype));
             if (newType !== type && type.typeAliasInfo) {
                 // Copy the type alias information if present.
-                newType = types_1.TypeBase.cloneForTypeAlias(newType, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
+                newType = types_1.TypeBase.cloneForTypeAlias(newType, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
             }
             return newType;
         }
@@ -752,7 +762,18 @@ function partiallySpecializeType(type, contextClassType, selfClass, typeClassTyp
 exports.partiallySpecializeType = partiallySpecializeType;
 function populateTypeVarContextForSelfType(typeVarContext, contextClassType, selfClass) {
     const synthesizedSelfTypeVar = synthesizeTypeVarForSelfCls(contextClassType, /* isClsParam */ false);
-    typeVarContext.setTypeVarType(synthesizedSelfTypeVar, convertToInstance(selfClass));
+    const selfInstance = convertToInstance(selfClass);
+    // We can't call stripLiteralValue here because that method requires the type evaluator.
+    // Instead, we'll do a simplified version of it here.
+    const selfWithoutLiteral = mapSubtypes(selfInstance, (subtype) => {
+        if ((0, types_1.isClass)(subtype)) {
+            if (subtype.literalValue !== undefined) {
+                return types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
+            }
+        }
+        return subtype;
+    });
+    typeVarContext.setTypeVarType(synthesizedSelfTypeVar, selfInstance, selfWithoutLiteral);
 }
 exports.populateTypeVarContextForSelfType = populateTypeVarContextForSelfType;
 // Looks for duplicate function types within the type and ensures that
@@ -1596,7 +1617,7 @@ function convertToInstance(type, includeSubclasses = true) {
     });
     // Copy over any type alias information.
     if (type.typeAliasInfo && type !== result) {
-        result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
+        result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
     }
     if (type !== result && includeSubclasses) {
         // Cache the converted value for next time.
@@ -1633,7 +1654,7 @@ function convertToInstantiable(type, includeSubclasses = true) {
     });
     // Copy over any type alias information.
     if (type.typeAliasInfo && type !== result) {
-        result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
+        result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
     }
     if (type !== result) {
         // Cache the converted value for next time.
@@ -2417,7 +2438,7 @@ class TypeVarTransformer {
                     return replacementType;
                 });
                 if (requiresUpdate) {
-                    return types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, typeArgs);
+                    return types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, typeArgs);
                 }
                 return type;
             }
@@ -2540,7 +2561,7 @@ class TypeVarTransformer {
             return updatedType;
         });
         return requiresUpdate
-            ? types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.typeParameters, newTypeArgs)
+            ? types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, newTypeArgs)
             : type;
     }
     transformTypeVarsInClassType(classType, recursionCount) {
@@ -2857,6 +2878,9 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
         return classType;
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
+        if (sourceType.trackedSignatures) {
+            this._signatureTracker.addTrackedSignatures(sourceType.trackedSignatures);
+        }
         // If this function is not generic, there's no need to check for uniqueness.
         if (sourceType.details.typeParameters.length === 0) {
             return super.transformTypeVarsInFunctionType(sourceType, recursionCount);
@@ -3103,6 +3127,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         const filteredOverloads = [];
         doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
             (0, debug_1.assert)((0, types_1.isFunction)(subtype));
+            subtype = types_1.FunctionType.cloneWithNewFlags(subtype, subtype.details.flags | 256 /* Overloaded */);
             filteredOverloads.push(subtype);
         });
         if (filteredOverloads.length === 1) {