codean-io
diff --git a/‎packages/pyright-internal/src/analyzer/checker.ts
Lines changed: 1 addition & 1 deletion b/‎packages/pyright-internal/src/analyzer/checker.ts
Lines changed: 1 addition & 1 deletion
diff --git a/‎packages/pyright-internal/src/analyzer/constraintSolver.ts
Lines changed: 4 additions & 36 deletions b/‎packages/pyright-internal/src/analyzer/constraintSolver.ts
Lines changed: 4 additions & 36 deletions
diff --git a/‎packages/pyright-internal/src/analyzer/typeEvaluator.ts
Lines changed: 13 additions & 58 deletions b/‎packages/pyright-internal/src/analyzer/typeEvaluator.ts
Lines changed: 13 additions & 58 deletions
diff --git a/‎packages/pyright-internal/src/analyzer/typePrinter.ts
Lines changed: 1 addition & 8 deletions b/‎packages/pyright-internal/src/analyzer/typePrinter.ts
Lines changed: 1 addition & 8 deletions
diff --git a/‎packages/pyright-internal/src/analyzer/typeUtils.ts
Lines changed: 3 additions & 2 deletions b/‎packages/pyright-internal/src/analyzer/typeUtils.ts
Lines changed: 3 additions & 2 deletions
@@ -3274,7 +3274,7 @@ export class Checker extends ParseTreeWalker {
 
         // If arg1IncludesSubclasses is true, it contains a Type[X] class rather than X. A Type[X]
         // could be a subclass of X, so the "unnecessary isinstance check" may be legit.
-        if (!arg1IncludesSubclasses && isTypeSame(filteredType, arg0Type, /* ignorePseudoGeneric */ true)) {
+        if (!arg1IncludesSubclasses && isTypeSame(filteredType, arg0Type, { ignorePseudoGeneric: true })) {
             this._evaluator.addDiagnostic(
                 this._fileInfo.diagnosticRuleSet.reportUnnecessaryIsInstance,
                 DiagnosticRule.reportUnnecessaryIsInstance,
 
@@ -397,15 +397,7 @@ export function assignTypeToTypeVar(
         // Update the wide type bound.
         if (!curWideTypeBound) {
             newWideTypeBound = adjSrcType;
-        } else if (
-            !isTypeSame(
-                curWideTypeBound,
-                adjSrcType,
-                /* ignorePseudoGeneric */ undefined,
-                /* ignoreTypeFlags */ undefined,
-                recursionCount
-            )
-        ) {
+        } else if (!isTypeSame(curWideTypeBound, adjSrcType, {}, recursionCount)) {
             if (
                 evaluator.assignType(
                     curWideTypeBound,
@@ -472,15 +464,7 @@ export function assignTypeToTypeVar(
         if (!curNarrowTypeBound) {
             // There was previously no narrow bound. We've now established one.
             newNarrowTypeBound = adjSrcType;
-        } else if (
-            !isTypeSame(
-                curNarrowTypeBound,
-                adjSrcType,
-                /* ignorePseudoGeneric */ undefined,
-                /* ignoreTypeFlags */ undefined,
-                recursionCount
-            )
-        ) {
+        } else if (!isTypeSame(curNarrowTypeBound, adjSrcType, {}, recursionCount)) {
             if (
                 evaluator.assignType(
                     curNarrowTypeBound,
@@ -573,15 +557,7 @@ export function assignTypeToTypeVar(
 
         // Make sure we don't exceed the wide type bound.
         if (curWideTypeBound && newNarrowTypeBound) {
-            if (
-                !isTypeSame(
-                    curWideTypeBound,
-                    newNarrowTypeBound,
-                    /* ignorePseudoGeneric */ undefined,
-                    /* ignoreTypeFlags */ undefined,
-                    recursionCount
-                )
-            ) {
+            if (!isTypeSame(curWideTypeBound, newNarrowTypeBound, {}, recursionCount)) {
                 let makeConcrete = true;
 
                 // Handle the case where the wide type is type T and the narrow type
@@ -687,15 +663,7 @@ function assignTypeToParamSpec(
         if (existingEntry) {
             if (existingEntry.parameters.length === 0 && existingEntry.paramSpec) {
                 // If there's an existing entry that matches, that's fine.
-                if (
-                    isTypeSame(
-                        existingEntry.paramSpec,
-                        srcType,
-                        /* ignorePseudoGeneric */ undefined,
-                        /* ignoreTypeFlags */ undefined,
-                        recursionCount
-                    )
-                ) {
+                if (isTypeSame(existingEntry.paramSpec, srcType, {}, recursionCount)) {
                     return true;
                 }
             }
 
@@ -7133,7 +7133,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
 
         const assertedType = convertToInstance(getTypeOfArgumentExpectingType(node.arguments[1]).type);
 
-        if (!isTypeSame(assertedType, arg0TypeResult.type)) {
+        if (!isTypeSame(assertedType, arg0TypeResult.type, { treatAnySameAsUnknown: true })) {
             addDiagnostic(
                 AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues,
                 DiagnosticRule.reportGeneralTypeIssues,
@@ -8442,11 +8442,9 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                             const castFromType = getTypeOfArgument(argList[1]).type;
                             if (isInstantiableClass(castToType) && isClassInstance(castFromType)) {
                                 if (
-                                    isTypeSame(
-                                        castToType,
-                                        ClassType.cloneAsInstantiable(castFromType),
-                                        /* ignorePseudoGeneric */ true
-                                    )
+                                    isTypeSame(castToType, ClassType.cloneAsInstantiable(castFromType), {
+                                        ignorePseudoGeneric: true,
+                                    })
                                 ) {
                                     addDiagnostic(
                                         AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast,
@@ -9877,7 +9875,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 type.strippedFirstParamType.typeArguments.forEach((typeArg, index) => {
                     if (index < typeParams.length) {
                         const typeParam = typeParams[index];
-                        if (!isTypeSame(typeParam, typeArg, /* ignorePseudoGeneric */ true)) {
+                        if (!isTypeSame(typeParam, typeArg, { ignorePseudoGeneric: true })) {
                             typeVarContext.setTypeVarType(typeParams[index], typeArg);
                         }
                     }
@@ -12128,7 +12126,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
             if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
                 valueType = combineTypes(valueTypes);
             } else {
-                valueType = areTypesSame(valueTypes, /* ignorePseudoGeneric */ true) ? valueTypes[0] : fallbackType;
+                valueType = areTypesSame(valueTypes, { ignorePseudoGeneric: true }) ? valueTypes[0] : fallbackType;
             }
         } else {
             valueType = fallbackType;
@@ -12461,7 +12459,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 inferredEntryType = combineTypes(entryTypes, maxSubtypesForInferredType);
             } else {
                 // Is the list or set homogeneous? If so, use stricter rules. Otherwise relax the rules.
-                inferredEntryType = areTypesSame(entryTypes, /* ignorePseudoGeneric */ true)
+                inferredEntryType = areTypesSame(entryTypes, { ignorePseudoGeneric: true })
                     ? entryTypes[0]
                     : inferredEntryType;
             }
@@ -20654,15 +20652,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                 srcType.tupleTypeArguments &&
                 srcType.tupleTypeArguments.length === 1
             ) {
-                if (
-                    isTypeSame(
-                        destType,
-                        srcType.tupleTypeArguments[0].type,
-                        /* ignorePseudoGeneric */ undefined,
-                        /* ignoreTypeFlags */ undefined,
-                        recursionCount
-                    )
-                ) {
+                if (isTypeSame(destType, srcType.tupleTypeArguments[0].type, {}, recursionCount)) {
                     return true;
                 }
             }
@@ -21334,15 +21324,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
     ): boolean {
         // Start by checking for an exact match. This is needed to handle unions
         // that contain recursive type aliases.
-        if (
-            isTypeSame(
-                srcType,
-                destType,
-                /* ignorePseudoGeneric */ undefined,
-                /* ignoreTypeFlags */ undefined,
-                recursionCount
-            )
-        ) {
+        if (isTypeSame(srcType, destType, {}, recursionCount)) {
             return true;
         }
 
@@ -21382,13 +21364,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                     remainingDestSubtypes.push(destSubtype);
                 } else {
                     const srcTypeIndex = remainingSrcSubtypes.findIndex((srcSubtype) =>
-                        isTypeSame(
-                            srcSubtype,
-                            destSubtype,
-                            /* ignorePseudoGeneric */ undefined,
-                            /* ignoreTypeFlags */ undefined,
-                            recursionCount
-                        )
+                        isTypeSame(srcSubtype, destSubtype, {}, recursionCount)
                     );
                     if (srcTypeIndex >= 0) {
                         remainingSrcSubtypes.splice(srcTypeIndex, 1);
@@ -21790,15 +21766,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
     function assignConditionalTypeToTypeVar(destType: TypeVarType, srcType: Type, recursionCount: number): boolean {
         // The srcType is assignable only if all of its subtypes are assignable.
         return !findSubtype(srcType, (srcSubtype) => {
-            if (
-                isTypeSame(
-                    destType,
-                    srcSubtype,
-                    /* ignorePseudoGeneric */ true,
-                    /* ignoreTypeFlags */ undefined,
-                    recursionCount
-                )
-            ) {
+            if (isTypeSame(destType, srcSubtype, { ignorePseudoGeneric: true }, recursionCount)) {
                 return false;
             }
 
@@ -22855,12 +22823,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
                     // dest param spec itself, it is not assignable in this case.
                     if (
                         !srcParamSpec ||
-                        !isTypeSame(
-                            srcParamSpec,
-                            destParamSpec,
-                            /* ignorePseudoGeneric */ false,
-                            /* ignoreTypeFlags */ true
-                        ) ||
+                        !isTypeSame(srcParamSpec, destParamSpec, { ignoreTypeFlags: true }) ||
                         remainingParams.length > 0
                     ) {
                         canAssign = false;
@@ -23448,15 +23411,7 @@ export function createTypeEvaluator(importLookup: ImportLookup, evaluatorOptions
         let effectiveSrcType: Type = srcType;
 
         if (isTypeVar(srcType)) {
-            if (
-                isTypeSame(
-                    srcType,
-                    destType,
-                    /* ignorePseudoGeneric */ undefined,
-                    /* ignoreTypeFlags */ undefined,
-                    recursionCount
-                )
-            ) {
+            if (isTypeSame(srcType, destType, {}, recursionCount)) {
                 return srcType;
             }
 
 
@@ -309,14 +309,7 @@ export function printType(
                             let foundMatch = false;
 
                             for (const unionSubtype of type.subtypes) {
-                                if (
-                                    isTypeSame(
-                                        sourceSubtype,
-                                        unionSubtype,
-                                        /* ignorePseudoGeneric */ undefined,
-                                        /* ignoreTypeFlags */ true
-                                    )
-                                ) {
+                                if (isTypeSame(sourceSubtype, unionSubtype, { ignoreTypeFlags: true })) {
                                     if (!subtypeHandledSet.has(unionSubtypeIndex)) {
                                         allSubtypesPreviouslyHandled = false;
                                     }
 
@@ -53,6 +53,7 @@ import {
     TypeCategory,
     TypeCondition,
     TypeFlags,
+    TypeSameOptions,
     TypeVarScopeId,
     TypeVarType,
     UnionType,
@@ -560,13 +561,13 @@ export function doForEachSubtype(
 }
 
 // Determines if all of the types in the array are the same.
-export function areTypesSame(types: Type[], ignorePseudoGeneric: boolean): boolean {
+export function areTypesSame(types: Type[], options: TypeSameOptions): boolean {
     if (types.length < 2) {
         return true;
     }
 
     for (let i = 1; i < types.length; i++) {
-        if (!isTypeSame(types[0], types[i], ignorePseudoGeneric)) {
+        if (!isTypeSame(types[0], types[i], options)) {
             return false;
         }
     }