@zzzen/pyright-internal 1.2.0-dev.20260823 → 1.2.0-dev.20260906

package/dist/analyzer/types.js

@@ -821,6 +821,14 @@ var ClassType;
         return !!(classType.shared.flags & 67108864 /* ClassTypeFlags.EnumMemberSetMayBeDynamicallyModified */);
     }
     ClassType.isEnumMemberSetMayBeDynamicallyModified = isEnumMemberSetMayBeDynamicallyModified;
+    function isNamedTupleClass(classType) {
+        return classType.shared.namedTupleEntries !== undefined;
+    }
+    ClassType.isNamedTupleClass = isNamedTupleClass;
+    function isDefinedAtSource(classType, fileUri, typeSourceId) {
+        return classType.shared.fileUri.equals(fileUri) && classType.shared.typeSourceId === typeSourceId;
+    }
+    ClassType.isDefinedAtSource = isDefinedAtSource;
     function isPropertyClass(classType) {
         return !!(classType.shared.flags & 128 /* ClassTypeFlags.PropertyClass */);
     }
@@ -2350,6 +2358,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         return true;
     }
     recursionCount++;
+    const recursiveOptions = options.ignoreTypeFlags ? { ...options, ignoreTypeFlags: false } : options;
     if (options.honorTypeForm) {
         const typeForm1 = type1.props?.typeForm;
         const typeForm2 = type2.props?.typeForm;
@@ -2377,31 +2386,35 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             if (!options.ignorePseudoGeneric || !ClassType.isPseudoGenericClass(type1)) {
                 // Make sure the type args match.
-                if (type1.priv.tupleTypeArgs && classType2.priv.tupleTypeArgs) {
-                    const type1TupleTypeArgs = type1.priv.tupleTypeArgs || [];
-                    const type2TupleTypeArgs = classType2.priv.tupleTypeArgs || [];
+                const type1TupleTypeArgs = type1.priv.tupleTypeArgs;
+                const type2TupleTypeArgs = classType2.priv.tupleTypeArgs;
+                if (type1TupleTypeArgs && type2TupleTypeArgs) {
                     if (type1TupleTypeArgs.length !== type2TupleTypeArgs.length) {
                         return false;
                     }
-                    for (let i = 0; i < type1TupleTypeArgs.length; i++) {
-                        if (!isTypeSame(type1TupleTypeArgs[i].type, type2TupleTypeArgs[i].type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
-                            return false;
-                        }
-                        if (type1TupleTypeArgs[i].isUnbounded !== type2TupleTypeArgs[i].isUnbounded) {
-                            return false;
+                    if (type1TupleTypeArgs !== type2TupleTypeArgs) {
+                        for (let i = 0; i < type1TupleTypeArgs.length; i++) {
+                            if (!isTypeSame(type1TupleTypeArgs[i].type, type2TupleTypeArgs[i].type, recursiveOptions, recursionCount)) {
+                                return false;
+                            }
+                            if (type1TupleTypeArgs[i].isUnbounded !== type2TupleTypeArgs[i].isUnbounded) {
+                                return false;
+                            }
                         }
                     }
                 }
                 else {
-                    const type1TypeArgs = type1.priv.typeArgs || [];
-                    const type2TypeArgs = classType2.priv.typeArgs || [];
-                    const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
-                    for (let i = 0; i < typeArgCount; i++) {
-                        // Assume that missing type args are "Unknown".
-                        const typeArg1 = i < type1TypeArgs.length ? type1TypeArgs[i] : UnknownType.create();
-                        const typeArg2 = i < type2TypeArgs.length ? type2TypeArgs[i] : UnknownType.create();
-                        if (!isTypeSame(typeArg1, typeArg2, { ...options, ignoreTypeFlags: false }, recursionCount)) {
-                            return false;
+                    const type1TypeArgs = type1.priv.typeArgs;
+                    const type2TypeArgs = classType2.priv.typeArgs;
+                    if (type1TypeArgs !== type2TypeArgs) {
+                        const typeArgCount = Math.max(type1TypeArgs?.length ?? 0, type2TypeArgs?.length ?? 0);
+                        for (let i = 0; i < typeArgCount; i++) {
+                            // Assume that missing type args are "Unknown".
+                            const typeArg1 = type1TypeArgs && i < type1TypeArgs.length ? type1TypeArgs[i] : UnknownType.create();
+                            const typeArg2 = type2TypeArgs && i < type2TypeArgs.length ? type2TypeArgs[i] : UnknownType.create();
+                            if (!isTypeSame(typeArg1, typeArg2, recursiveOptions, recursionCount)) {
+                                return false;
+                            }
                         }
                     }
                 }
@@ -2437,35 +2450,43 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             if (FunctionType.isGradualCallableForm(type1) !== FunctionType.isGradualCallableForm(functionType2)) {
                 return false;
             }
-            const positionOnlyIndex1 = params1.findIndex((param) => isPositionOnlySeparator(param));
-            const positionOnlyIndex2 = params2.findIndex((param) => isPositionOnlySeparator(param));
-            // Make sure the parameter details match.
-            for (let i = 0; i < params1.length; i++) {
-                const param1 = params1[i];
-                const param2 = params2[i];
-                if (param1.category !== param2.category) {
-                    return false;
-                }
-                const isName1Relevant = positionOnlyIndex1 !== undefined && i > positionOnlyIndex1;
-                const isName2Relevant = positionOnlyIndex2 !== undefined && i > positionOnlyIndex2;
-                if (isName1Relevant !== isName2Relevant) {
-                    return false;
-                }
-                if (isName1Relevant) {
-                    if (param1.name !== param2.name) {
+            const specializedTypes1 = type1.priv.specializedTypes;
+            const specializedTypes2 = functionType2.priv.specializedTypes;
+            if (type1.shared === functionType2.shared && specializedTypes1 === specializedTypes2) {
+                return true;
+            }
+            const haveSameParamSignature = params1 === params2 && specializedTypes1?.parameterTypes === specializedTypes2?.parameterTypes;
+            if (!haveSameParamSignature) {
+                const positionOnlyIndex1 = params1.findIndex((param) => isPositionOnlySeparator(param));
+                const positionOnlyIndex2 = params2.findIndex((param) => isPositionOnlySeparator(param));
+                // Make sure the parameter details match.
+                for (let i = 0; i < params1.length; i++) {
+                    const param1 = params1[i];
+                    const param2 = params2[i];
+                    if (param1.category !== param2.category) {
+                        return false;
+                    }
+                    const isName1Relevant = positionOnlyIndex1 !== undefined && i > positionOnlyIndex1;
+                    const isName2Relevant = positionOnlyIndex2 !== undefined && i > positionOnlyIndex2;
+                    if (isName1Relevant !== isName2Relevant) {
+                        return false;
+                    }
+                    if (isName1Relevant) {
+                        if (param1.name !== param2.name) {
+                            return false;
+                        }
+                    }
+                    else if (isPositionOnlySeparator(param1) && isPositionOnlySeparator(param2)) {
+                        continue;
+                    }
+                    else if (isKeywordOnlySeparator(param1) && isKeywordOnlySeparator(param2)) {
+                        continue;
+                    }
+                    const param1Type = FunctionType.getParamType(type1, i);
+                    const param2Type = FunctionType.getParamType(functionType2, i);
+                    if (!isTypeSame(param1Type, param2Type, recursiveOptions, recursionCount)) {
                         return false;
                     }
-                }
-                else if (isPositionOnlySeparator(param1) && isPositionOnlySeparator(param2)) {
-                    continue;
-                }
-                else if (isKeywordOnlySeparator(param1) && isKeywordOnlySeparator(param2)) {
-                    continue;
-                }
-                const param1Type = FunctionType.getParamType(type1, i);
-                const param2Type = FunctionType.getParamType(functionType2, i);
-                if (!isTypeSame(param1Type, param2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
-                    return false;
                 }
             }
             // Make sure the return types match.
@@ -2486,7 +2507,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             if (return1Type || return2Type) {
                 if (!return1Type ||
                     !return2Type ||
-                    !isTypeSame(return1Type, return2Type, { ...options, ignoreTypeFlags: false }, recursionCount)) {
+                    !isTypeSame(return1Type, return2Type, recursiveOptions, recursionCount)) {
                     return false;
                 }
             }
@@ -2495,6 +2516,9 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         case 5 /* TypeCategory.Overloaded */: {
             // Make sure the overload counts match.
             const functionType2 = type2;
+            if (type1.priv._overloads === functionType2.priv._overloads) {
+                return true;
+            }
             if (type1.priv._overloads.length !== functionType2.priv._overloads.length) {
                 return false;
             }
@@ -2514,6 +2538,9 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             if (subtypes1.length !== subtypes2.length) {
                 return false;
             }
+            if (subtypes1 === subtypes2) {
+                return true;
+            }
             // The types do not have a particular order, so we need to
             // do the comparison in an order-independent manner.
             const exclusionSet = new Set();
@@ -2537,7 +2564,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                     // Assume that missing type args are "Any".
                     const typeArg1 = i < type1TypeArgs.length ? type1TypeArgs[i] : AnyType.create();
                     const typeArg2 = i < type2TypeArgs.length ? type2TypeArgs[i] : AnyType.create();
-                    if (!isTypeSame(typeArg1, typeArg2, { ...options, ignoreTypeFlags: false }, recursionCount)) {
+                    if (!isTypeSame(typeArg1, typeArg2, recursiveOptions, recursionCount)) {
                         return false;
                     }
                 }
@@ -2564,26 +2591,25 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             }
             const boundType1 = type1.shared.boundType;
             const boundType2 = type2TypeVar.shared.boundType;
-            if (boundType1) {
-                if (!boundType2 ||
-                    !isTypeSame(boundType1, boundType2, { ...options, ignoreTypeFlags: false }, recursionCount)) {
+            if (boundType1 !== boundType2) {
+                if (!boundType1 || !boundType2) {
                     return false;
                 }
-            }
-            else {
-                if (boundType2) {
+                if (!isTypeSame(boundType1, boundType2, recursiveOptions, recursionCount)) {
                     return false;
                 }
             }
             const constraints1 = type1.shared.constraints;
             const constraints2 = type2TypeVar.shared.constraints;
-            if (constraints1.length !== constraints2.length) {
-                return false;
-            }
-            for (let i = 0; i < constraints1.length; i++) {
-                if (!isTypeSame(constraints1[i], constraints2[i], { ...options, ignoreTypeFlags: false }, recursionCount)) {
+            if (constraints1 !== constraints2) {
+                if (constraints1.length !== constraints2.length) {
                     return false;
                 }
+                for (let i = 0; i < constraints1.length; i++) {
+                    if (!isTypeSame(constraints1[i], constraints2[i], recursiveOptions, recursionCount)) {
+                        return false;
+                    }
+                }
             }
             return true;
         }