@zzzen/pyright-internal 1.2.0-dev.20230416 → 1.2.0-dev.20230423

package/dist/analyzer/typeGuards.js

@@ -29,7 +29,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enumerateLiteralsForType = exports.narrowTypeForContainerElementType = exports.getElementTypeForContainerNarrowing = exports.isIsinstanceFilterSubclass = exports.isIsinstanceFilterSuperclass = exports.getTypeNarrowingCallback = void 0;
+exports.enumerateLiteralsForType = exports.narrowTypeForDiscriminatedTupleComparison = exports.narrowTypeForDiscriminatedDictEntryComparison = exports.narrowTypeForContainerElementType = exports.getElementTypeForContainerNarrowing = exports.isIsinstanceFilterSubclass = exports.isIsinstanceFilterSuperclass = exports.getTypeNarrowingCallback = void 0;
 const parseNodes_1 = require("../parser/parseNodes");
 const analyzerNodeInfo_1 = require("./analyzerNodeInfo");
 const constraintSolver_1 = require("./constraintSolver");
@@ -38,7 +38,6 @@ const scopeUtils_1 = require("./scopeUtils");
 const symbol_1 = require("./symbol");
 const typedDicts_1 = require("./typedDicts");
 const types_1 = require("./types");
-const types_2 = require("./types");
 const typeUtils_1 = require("./typeUtils");
 const typeVarContext_1 = require("./typeVarContext");
 // Given a reference expression and a test expression, returns a callback that
@@ -46,7 +45,7 @@ const typeVarContext_1 = require("./typeVarContext");
 // If the specified flow node is not associated with the test expression,
 // it returns undefined.
 function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositiveTest, recursionCount = 0) {
-    if (recursionCount > types_2.maxTypeRecursionCount) {
+    if (recursionCount > types_1.maxTypeRecursionCount) {
         return undefined;
     }
     recursionCount++;
@@ -120,10 +119,10 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     const arg0Expr = testExpression.leftExpression.arguments[0].valueExpression;
                     if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                         const callType = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* DoNotSpecialize */).type;
-                        if ((0, types_2.isInstantiableClass)(callType) && types_2.ClassType.isBuiltIn(callType, 'type')) {
+                        if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type')) {
                             const classTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                             const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
-                            if ((0, types_2.isInstantiableClass)(classType)) {
+                            if ((0, types_1.isInstantiableClass)(classType)) {
                                 return (type) => {
                                     return {
                                         type: narrowTypeForTypeIs(evaluator, type, classType, adjIsPositiveTest),
@@ -140,8 +139,8 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
                     const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                     const rightType = rightTypeResult.type;
-                    if ((0, types_2.isClassInstance)(rightType) &&
-                        (types_2.ClassType.isEnumClass(rightType) || types_2.ClassType.isBuiltIn(rightType, 'bool')) &&
+                    if ((0, types_1.isClassInstance)(rightType) &&
+                        (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
                         rightType.literalValue !== undefined) {
                         return (type) => {
                             return {
@@ -160,10 +159,10 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
                     const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
                     const indexType = indexTypeResult.type;
-                    if ((0, types_2.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
-                        if (types_2.ClassType.isBuiltIn(indexType, 'str')) {
+                    if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
+                        if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
                             const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
-                            if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 return (type) => {
                                     return {
                                         type: narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
@@ -172,13 +171,13 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                                 };
                             }
                         }
-                        else if (types_2.ClassType.isBuiltIn(indexType, 'int')) {
+                        else if (types_1.ClassType.isBuiltIn(indexType, 'int')) {
                             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                             const rightType = rightTypeResult.type;
-                            if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 let canNarrow = false;
                                 // Narrowing can be applied only for bool or enum literals.
-                                if (types_2.ClassType.isBuiltIn(rightType, 'bool')) {
+                                if (types_1.ClassType.isBuiltIn(rightType, 'bool')) {
                                     canNarrow = true;
                                 }
                                 else if (rightType.literalValue instanceof types_1.EnumLiteral) {
@@ -203,7 +202,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 if (ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression)) {
                     const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                     const rightType = rightTypeResult.type;
-                    if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                    if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                         return (type) => {
                             return {
                                 type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
@@ -221,26 +220,22 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                     ParseTreeUtils.isMatchingExpression(reference, testExpression.leftExpression.baseExpression)) {
                     const indexTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.items[0].valueExpression);
                     const indexType = indexTypeResult.type;
-                    if ((0, types_2.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
-                        if (types_2.ClassType.isBuiltIn(indexType, 'str')) {
-                            const rightType = evaluator.getTypeOfExpression(testExpression.rightExpression).type;
-                            if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
-                                return (type) => {
-                                    return {
-                                        type: narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
-                                        isIncomplete: !!indexTypeResult.isIncomplete,
-                                    };
-                                };
-                            }
-                        }
-                        else if (types_2.ClassType.isBuiltIn(indexType, 'int')) {
+                    if ((0, types_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
+                        if (types_1.ClassType.isBuiltIn(indexType, ['str', 'int'])) {
                             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                             const rightType = rightTypeResult.type;
-                            if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 return (type) => {
+                                    let narrowedType;
+                                    if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
+                                        narrowedType = narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest);
+                                    }
+                                    else {
+                                        narrowedType = narrowTypeForDiscriminatedTupleComparison(evaluator, type, indexType, rightType, adjIsPositiveTest);
+                                    }
                                     return {
-                                        type: narrowTypeForDiscriminatedTupleComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
-                                        isIncomplete: !!rightTypeResult.isIncomplete,
+                                        type: narrowedType,
+                                        isIncomplete: !!indexTypeResult.isIncomplete || !!rightTypeResult.isIncomplete,
                                     };
                                 };
                             }
@@ -258,7 +253,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                     const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression.leftExpression, 2 /* DoNotSpecialize */);
                     const callType = callTypeResult.type;
-                    if ((0, types_2.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
+                    if ((0, types_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
                         const tupleLength = testExpression.rightExpression.value;
                         if (typeof tupleLength === 'number') {
                             return (type) => {
@@ -278,7 +273,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                 const rightType = rightTypeResult.type;
                 const memberName = testExpression.leftExpression.memberName;
-                if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                     return (type) => {
                         return {
                             type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
@@ -294,8 +289,8 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                 const rightType = rightTypeResult.type;
                 const memberName = testExpression.leftExpression.memberName;
-                if ((0, types_2.isClassInstance)(rightType) &&
-                    (types_2.ClassType.isEnumClass(rightType) || types_2.ClassType.isBuiltIn(rightType, 'bool')) &&
+                if ((0, types_1.isClassInstance)(rightType) &&
+                    (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
                     rightType.literalValue !== undefined) {
                     return (type) => {
                         return {
@@ -338,11 +333,11 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 // one or more TypedDicts.
                 const leftTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression);
                 const leftType = leftTypeResult.type;
-                if ((0, types_2.isClassInstance)(leftType) && types_2.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
+                if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
                     const adjIsPositiveTest = testExpression.operator === 41 /* In */ ? isPositiveTest : !isPositiveTest;
                     return (type) => {
                         return {
-                            type: narrowTypeForTypedDictKey(evaluator, type, types_2.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
+                            type: narrowTypeForTypedDictKey(evaluator, type, types_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
                             isIncomplete: !!leftTypeResult.isIncomplete,
                         };
                     };
@@ -361,7 +356,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                 const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
                 const callType = callTypeResult.type;
-                if ((0, types_2.isFunction)(callType) &&
+                if ((0, types_1.isFunction)(callType) &&
                     (callType.details.builtInName === 'isinstance' || callType.details.builtInName === 'issubclass')) {
                     const isInstanceCheck = callType.details.builtInName === 'isinstance';
                     const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 8 /* EvaluateStringLiteralAsType */ |
@@ -374,7 +369,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         return (type) => {
                             const narrowedType = narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, 
                             /* allowIntersections */ false, testExpression);
-                            if (!(0, types_2.isNever)(narrowedType)) {
+                            if (!(0, types_1.isNever)(narrowedType)) {
                                 return {
                                     type: narrowedType,
                                     isIncomplete,
@@ -407,11 +402,11 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             if (ParseTreeUtils.isMatchingExpression(reference, arg0Expr)) {
                 const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
                 const callType = callTypeResult.type;
-                if ((0, types_2.isFunction)(callType) && callType.details.builtInName === 'callable') {
+                if ((0, types_1.isFunction)(callType) && callType.details.builtInName === 'callable') {
                     return (type) => {
                         let narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
                         /* allowIntersections */ false);
-                        if (isPositiveTest && (0, types_2.isNever)(narrowedType)) {
+                        if (isPositiveTest && (0, types_1.isNever)(narrowedType)) {
                             // Try again with intersections allowed.
                             narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
                             /* allowIntersections */ true);
@@ -426,7 +421,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
             if (ParseTreeUtils.isMatchingExpression(reference, testExpression.arguments[0].valueExpression)) {
                 const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
                 const callType = callTypeResult.type;
-                if ((0, types_2.isInstantiableClass)(callType) && types_2.ClassType.isBuiltIn(callType, 'bool')) {
+                if ((0, types_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
                     return (type) => {
                         return {
                             type: narrowTypeForTruthiness(evaluator, type, isPositiveTest),
@@ -444,27 +439,27 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 let isPossiblyTypeGuard = false;
                 const isFunctionReturnTypeGuard = (type) => {
                     return (type.details.declaredReturnType &&
-                        (0, types_2.isClassInstance)(type.details.declaredReturnType) &&
-                        types_2.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'StrictTypeGuard']));
+                        (0, types_1.isClassInstance)(type.details.declaredReturnType) &&
+                        types_1.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'StrictTypeGuard']));
                 };
                 const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
                 const callType = callTypeResult.type;
-                if ((0, types_2.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
+                if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
                     isPossiblyTypeGuard = true;
                 }
-                else if ((0, types_2.isOverloadedFunction)(callType) &&
-                    types_2.OverloadedFunctionType.getOverloads(callType).some((o) => isFunctionReturnTypeGuard(o))) {
+                else if ((0, types_1.isOverloadedFunction)(callType) &&
+                    types_1.OverloadedFunctionType.getOverloads(callType).some((o) => isFunctionReturnTypeGuard(o))) {
                     isPossiblyTypeGuard = true;
                 }
-                else if ((0, types_2.isClassInstance)(callType)) {
+                else if ((0, types_1.isClassInstance)(callType)) {
                     isPossiblyTypeGuard = true;
                 }
                 if (isPossiblyTypeGuard) {
                     // Evaluate the type guard call expression.
                     const functionReturnTypeResult = evaluator.getTypeOfExpression(testExpression);
                     const functionReturnType = functionReturnTypeResult.type;
-                    if ((0, types_2.isClassInstance)(functionReturnType) &&
-                        types_2.ClassType.isBuiltIn(functionReturnType, 'bool') &&
+                    if ((0, types_1.isClassInstance)(functionReturnType) &&
+                        types_1.ClassType.isBuiltIn(functionReturnType, 'bool') &&
                         functionReturnType.typeGuardType) {
                         const isStrictTypeGuard = !!functionReturnType.isStrictTypeGuard;
                         const typeGuardType = functionReturnType.typeGuardType;
@@ -648,12 +643,12 @@ function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
         }
         const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.tupleTypeArguments[indexValue].type);
         if (isPositiveTest) {
-            if (!evaluator.assignType(typeOfEntry, types_2.NoneType.createInstance())) {
+            if (!evaluator.assignType(typeOfEntry, types_1.NoneType.createInstance())) {
                 return undefined;
             }
         }
         else {
-            if ((0, types_2.isNoneInstance)(typeOfEntry)) {
+            if ((0, types_1.isNoneInstance)(typeOfEntry)) {
                 return undefined;
             }
         }
@@ -667,7 +662,7 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
     });
     return evaluator.mapSubtypesExpandTypeVars(expandedType, 
     /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
-        if ((0, types_2.isAnyOrUnknown)(subtype)) {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
             // We need to assume that "Any" is always both None and not None,
             // so it matches regardless of whether the test is positive or negative.
             return subtype;
@@ -675,17 +670,17 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
         // If this is a TypeVar that isn't constrained, use the unexpanded
         // TypeVar. For all other cases (including constrained TypeVars),
         // use the expanded subtype.
-        const adjustedSubtype = (0, types_2.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
             ? unexpandedSubtype
             : subtype;
         // See if it's a match for object.
-        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'object')) {
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
             return isPositiveTest
-                ? (0, typeUtils_1.addConditionToType)(types_2.NoneType.createInstance(), subtype.condition)
+                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
                 : adjustedSubtype;
         }
         // See if it's a match for None.
-        if ((0, types_2.isNoneInstance)(subtype) === isPositiveTest) {
+        if ((0, types_1.isNoneInstance)(subtype) === isPositiveTest) {
             return subtype;
         }
         return undefined;
@@ -698,7 +693,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
     });
     return evaluator.mapSubtypesExpandTypeVars(expandedType, 
     /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
-        if ((0, types_2.isAnyOrUnknown)(subtype)) {
+        if ((0, types_1.isAnyOrUnknown)(subtype)) {
             // We need to assume that "Any" is always both None and not None,
             // so it matches regardless of whether the test is positive or negative.
             return subtype;
@@ -706,16 +701,16 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
         // If this is a TypeVar that isn't constrained, use the unexpanded
         // TypeVar. For all other cases (including constrained TypeVars),
         // use the expanded subtype.
-        const adjustedSubtype = (0, types_2.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+        const adjustedSubtype = (0, types_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
             ? unexpandedSubtype
             : subtype;
         // See if it's a match for object.
-        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'object')) {
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
             return isPositiveTest
-                ? (0, typeUtils_1.addConditionToType)(types_2.NoneType.createInstance(), subtype.condition)
+                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
                 : adjustedSubtype;
         }
-        const isEllipsis = (0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'ellipsis');
+        const isEllipsis = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'ellipsis');
         // See if it's a match for "...".
         if (isEllipsis === isPositiveTest) {
             return subtype;
@@ -734,13 +729,13 @@ function getIsInstanceClassTypes(argType) {
     // undefined if any of the types are not valid.
     const addClassTypesToList = (types) => {
         types.forEach((subtype) => {
-            if ((0, types_2.isInstantiableClass)(subtype) || ((0, types_2.isTypeVar)(subtype) && types_2.TypeBase.isInstantiable(subtype))) {
+            if ((0, types_1.isInstantiableClass)(subtype) || ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstantiable(subtype))) {
                 classTypeList.push(subtype);
             }
-            else if ((0, types_2.isNoneTypeClass)(subtype)) {
+            else if ((0, types_1.isNoneTypeClass)(subtype)) {
                 classTypeList.push(subtype);
             }
-            else if ((0, types_2.isFunction)(subtype) &&
+            else if ((0, types_1.isFunction)(subtype) &&
                 subtype.details.parameters.length === 2 &&
                 subtype.details.parameters[0].category === 1 /* VarArgList */ &&
                 subtype.details.parameters[1].category === 2 /* VarArgDictionary */) {
@@ -752,10 +747,10 @@ function getIsInstanceClassTypes(argType) {
         });
     };
     const addClassTypesRecursive = (subtype, recursionCount = 0) => {
-        if (recursionCount > types_2.maxTypeRecursionCount) {
+        if (recursionCount > types_1.maxTypeRecursionCount) {
             return;
         }
-        if ((0, types_2.isClass)(subtype) && types_2.TypeBase.isInstance(subtype) && (0, typeUtils_1.isTupleClass)(subtype)) {
+        if ((0, types_1.isClass)(subtype) && types_1.TypeBase.isInstance(subtype) && (0, typeUtils_1.isTupleClass)(subtype)) {
             if (subtype.tupleTypeArguments) {
                 subtype.tupleTypeArguments.forEach((tupleEntry) => {
                     addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
@@ -778,32 +773,32 @@ function isIsinstanceFilterSuperclass(evaluator, varType, filterType, concreteFi
     if (concreteFilterType.includeSubclasses) {
         return false;
     }
-    if ((0, types_2.isTypeVar)(filterType)) {
+    if ((0, types_1.isTypeVar)(filterType)) {
         return false;
     }
-    if (types_2.ClassType.isDerivedFrom(varType, concreteFilterType)) {
+    if (types_1.ClassType.isDerivedFrom(varType, concreteFilterType)) {
         return true;
     }
     if (isInstanceCheck) {
-        if (types_2.ClassType.isProtocolClass(concreteFilterType) && evaluator.assignType(concreteFilterType, varType)) {
+        if (types_1.ClassType.isProtocolClass(concreteFilterType) && evaluator.assignType(concreteFilterType, varType)) {
             return true;
         }
     }
     // Handle the special case where the variable type is a TypedDict and
     // we're filtering against 'dict'. TypedDict isn't derived from dict,
     // but at runtime, isinstance returns True.
-    if (types_2.ClassType.isBuiltIn(concreteFilterType, 'dict') && types_2.ClassType.isTypedDictClass(varType)) {
+    if (types_1.ClassType.isBuiltIn(concreteFilterType, 'dict') && types_1.ClassType.isTypedDictClass(varType)) {
         return true;
     }
     return false;
 }
 exports.isIsinstanceFilterSuperclass = isIsinstanceFilterSuperclass;
 function isIsinstanceFilterSubclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck) {
-    if (types_2.ClassType.isDerivedFrom(concreteFilterType, varType)) {
+    if (types_1.ClassType.isDerivedFrom(concreteFilterType, varType)) {
         return true;
     }
     if (isInstanceCheck) {
-        if (types_2.ClassType.isProtocolClass(varType) && evaluator.assignType(varType, concreteFilterType)) {
+        if (types_1.ClassType.isProtocolClass(varType) && evaluator.assignType(varType, concreteFilterType)) {
             return true;
         }
     }
@@ -828,7 +823,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
         let isClassRelationshipIndeterminate = false;
         for (const filterType of classTypeList) {
             const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
-            if ((0, types_2.isInstantiableClass)(concreteFilterType)) {
+            if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
                 const filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck);
                 const filterIsSubclass = isIsinstanceFilterSubclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck);
                 if (filterIsSuperclass) {
@@ -841,7 +836,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                 // will generate false positives.
                 if (filterIsSubclass &&
                     filterIsSuperclass &&
-                    !types_2.ClassType.isSameGenericClass(varType, concreteFilterType)) {
+                    !types_1.ClassType.isSameGenericClass(varType, concreteFilterType)) {
                     isClassRelationshipIndeterminate = true;
                 }
                 if (isPositiveTest) {
@@ -857,11 +852,11 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                         // Try to retain the type arguments for the filter type. This is
                         // important because a specialized version of the filter cannot
                         // be passed to isinstance or issubclass.
-                        if ((0, types_2.isClass)(filterType)) {
-                            if (types_2.ClassType.isSpecialBuiltIn(filterType) ||
+                        if ((0, types_1.isClass)(filterType)) {
+                            if (types_1.ClassType.isSpecialBuiltIn(filterType) ||
                                 filterType.details.typeParameters.length > 0) {
                                 const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
-                                const unspecializedFilterType = types_2.ClassType.cloneForSpecialization(filterType, 
+                                const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType, 
                                 /* typeArguments */ undefined, 
                                 /* isTypeArgumentExplicit */ false);
                                 if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, varType, typeVarContext, 
@@ -880,38 +875,38 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                         // the two types.
                         const className = `<subclass of ${varType.details.name} and ${concreteFilterType.details.name}>`;
                         const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-                        let newClassType = types_2.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
                         /* declaredMetaclass */ undefined, varType.details.effectiveMetaclass, varType.details.docString);
-                        newClassType.details.baseClasses = [types_2.ClassType.cloneAsInstantiable(varType), concreteFilterType];
+                        newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(varType), concreteFilterType];
                         (0, typeUtils_1.computeMroLinearization)(newClassType);
                         newClassType = (0, typeUtils_1.addConditionToType)(newClassType, concreteFilterType.condition);
-                        if ((0, types_2.isTypeVar)(unexpandedType) &&
+                        if ((0, types_1.isTypeVar)(unexpandedType) &&
                             !unexpandedType.details.isParamSpec &&
                             unexpandedType.details.constraints.length === 0) {
                             newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [
                                 {
-                                    typeVarName: types_2.TypeVarType.getNameWithScope(unexpandedType),
+                                    typeVarName: types_1.TypeVarType.getNameWithScope(unexpandedType),
                                     constraintIndex: 0,
                                     isConstrainedTypeVar: false,
                                 },
                             ]);
                         }
-                        let newClassInstanceType = types_2.ClassType.cloneAsInstance(newClassType);
+                        let newClassInstanceType = types_1.ClassType.cloneAsInstance(newClassType);
                         if (varType.condition) {
                             newClassInstanceType = (0, typeUtils_1.addConditionToType)(newClassInstanceType, varType.condition);
                         }
                         // If this is a issubclass check, we do a double conversion from instantiable
                         // to instance back to instantiable to make sure that the includeSubclasses flag
                         // gets cleared.
-                        filteredTypes.push(isInstanceCheck ? newClassInstanceType : types_2.ClassType.cloneAsInstantiable(newClassInstanceType));
+                        filteredTypes.push(isInstanceCheck ? newClassInstanceType : types_1.ClassType.cloneAsInstantiable(newClassInstanceType));
                     }
                 }
             }
-            else if ((0, types_2.isTypeVar)(filterType) && types_2.TypeBase.isInstantiable(filterType)) {
+            else if ((0, types_1.isTypeVar)(filterType) && types_1.TypeBase.isInstantiable(filterType)) {
                 // Handle the case where the filter type is Type[T] and the unexpanded
                 // subtype is some instance type, possibly T.
-                if (isInstanceCheck && types_2.TypeBase.isInstance(unexpandedType)) {
-                    if ((0, types_2.isTypeVar)(unexpandedType) && (0, types_2.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), unexpandedType)) {
+                if (isInstanceCheck && types_1.TypeBase.isInstance(unexpandedType)) {
+                    if ((0, types_1.isTypeVar)(unexpandedType) && (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), unexpandedType)) {
                         // If the unexpanded subtype is T, we can definitively filter
                         // in both the positive and negative cases.
                         if (isPositiveTest) {
@@ -930,8 +925,8 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                         }
                     }
                 }
-                else if (!isInstanceCheck && types_2.TypeBase.isInstantiable(unexpandedType)) {
-                    if ((0, types_2.isTypeVar)(unexpandedType) && (0, types_2.isTypeSame)(filterType, unexpandedType)) {
+                else if (!isInstanceCheck && types_1.TypeBase.isInstantiable(unexpandedType)) {
+                    if ((0, types_1.isTypeVar)(unexpandedType) && (0, types_1.isTypeSame)(filterType, unexpandedType)) {
                         if (isPositiveTest) {
                             filteredTypes.push(unexpandedType);
                         }
@@ -947,12 +942,12 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                     }
                 }
             }
-            else if ((0, types_2.isFunction)(filterType)) {
+            else if ((0, types_1.isFunction)(filterType)) {
                 // Handle an isinstance check against Callable.
                 if (isInstanceCheck) {
                     let isCallable = false;
-                    if ((0, types_2.isClass)(varType)) {
-                        if (types_2.TypeBase.isInstantiable(unexpandedType)) {
+                    if ((0, types_1.isClass)(varType)) {
+                        if (types_1.TypeBase.isInstantiable(unexpandedType)) {
                             isCallable = true;
                         }
                         else {
@@ -984,7 +979,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             // We perform a double conversion from instance to instantiable
             // here to make sure that the includeSubclasses flag is cleared
             // if it's a class.
-            return filteredTypes.map((t) => ((0, types_2.isInstantiableClass)(t) ? (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(t)) : t));
+            return filteredTypes.map((t) => ((0, types_1.isInstantiableClass)(t) ? (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(t)) : t));
         }
         return filteredTypes.map((t) => (0, typeUtils_1.convertToInstance)(t));
     };
@@ -996,7 +991,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                 if (evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType))) {
                     // If the filter type is a Callable, use the original type. If the
                     // filter type is a callback protocol, use the filter type.
-                    if ((0, types_2.isFunction)(filterType)) {
+                    if ((0, types_1.isFunction)(filterType)) {
                         filteredTypes.push(unexpandedType);
                     }
                     else {
@@ -1009,7 +1004,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             // If the filter type is a runtime checkable protocol class, it can
             // be used in an instance check.
             const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
-            if ((0, types_2.isClass)(concreteFilterType) && !types_2.ClassType.isProtocolClass(concreteFilterType)) {
+            if ((0, types_1.isClass)(concreteFilterType) && !types_1.ClassType.isProtocolClass(concreteFilterType)) {
                 return false;
             }
             return evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType));
@@ -1028,30 +1023,30 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
         // on a constrained TypeVar that they want to filter based on its constrained
         // parts.
         const negativeFallback = (0, typeUtils_1.getTypeCondition)(subtype) ? subtype : unexpandedSubtype;
-        const isSubtypeTypeObject = (0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'type');
-        if (isPositiveTest && (0, types_2.isAnyOrUnknown)(subtype)) {
+        const isSubtypeTypeObject = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'type');
+        if (isPositiveTest && (0, types_1.isAnyOrUnknown)(subtype)) {
             // If this is a positive test and the effective type is Any or
             // Unknown, we can assume that the type matches one of the
             // specified types.
             if (isInstanceCheck) {
-                anyOrUnknownSubstitutions.push((0, types_2.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstance)(classType))));
+                anyOrUnknownSubstitutions.push((0, types_1.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstance)(classType))));
             }
             else {
                 // We perform a double conversion from instance to instantiable
                 // here to make sure that the includeSubclasses flag is cleared
                 // if it's a class.
-                anyOrUnknownSubstitutions.push((0, types_2.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(classType)))));
+                anyOrUnknownSubstitutions.push((0, types_1.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(classType)))));
             }
             anyOrUnknown.push(subtype);
             return undefined;
         }
         if (isInstanceCheck) {
-            if ((0, types_2.isNoneInstance)(subtype)) {
+            if ((0, types_1.isNoneInstance)(subtype)) {
                 const containsNoneType = classTypeList.some((t) => {
-                    if ((0, types_2.isNoneTypeClass)(t)) {
+                    if ((0, types_1.isNoneTypeClass)(t)) {
                         return true;
                     }
-                    return (0, types_2.isInstantiableClass)(t) && types_2.ClassType.isBuiltIn(t, 'NoneType');
+                    return (0, types_1.isInstantiableClass)(t) && types_1.ClassType.isBuiltIn(t, 'NoneType');
                 });
                 if (isPositiveTest) {
                     return containsNoneType ? subtype : undefined;
@@ -1060,28 +1055,28 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                     return containsNoneType ? undefined : subtype;
                 }
             }
-            if ((0, types_2.isModule)(subtype) || ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'ModuleType'))) {
+            if ((0, types_1.isModule)(subtype) || ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'ModuleType'))) {
                 // Handle type narrowing for runtime-checkable protocols
                 // when applied to modules.
                 if (isPositiveTest) {
                     const filteredTypes = classTypeList.filter((classType) => {
                         const concreteClassType = evaluator.makeTopLevelTypeVarsConcrete(classType);
-                        return ((0, types_2.isInstantiableClass)(concreteClassType) && types_2.ClassType.isProtocolClass(concreteClassType));
+                        return ((0, types_1.isInstantiableClass)(concreteClassType) && types_1.ClassType.isProtocolClass(concreteClassType));
                     });
                     if (filteredTypes.length > 0) {
-                        return (0, typeUtils_1.convertToInstance)((0, types_2.combineTypes)(filteredTypes));
+                        return (0, typeUtils_1.convertToInstance)((0, types_1.combineTypes)(filteredTypes));
                     }
                 }
             }
-            if ((0, types_2.isClassInstance)(subtype) && !isSubtypeTypeObject) {
-                return (0, types_2.combineTypes)(filterClassType(types_2.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.convertToInstance)(unexpandedSubtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+            if ((0, types_1.isClassInstance)(subtype) && !isSubtypeTypeObject) {
+                return (0, types_1.combineTypes)(filterClassType(types_1.ClassType.cloneAsInstantiable(subtype), (0, typeUtils_1.convertToInstance)(unexpandedSubtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
             }
-            if (((0, types_2.isFunction)(subtype) || (0, types_2.isOverloadedFunction)(subtype)) && isInstanceCheck) {
-                return (0, types_2.combineTypes)(filterFunctionType(subtype, (0, typeUtils_1.convertToInstance)(unexpandedSubtype)));
+            if (((0, types_1.isFunction)(subtype) || (0, types_1.isOverloadedFunction)(subtype)) && isInstanceCheck) {
+                return (0, types_1.combineTypes)(filterFunctionType(subtype, (0, typeUtils_1.convertToInstance)(unexpandedSubtype)));
             }
-            if ((0, types_2.isInstantiableClass)(subtype) || isSubtypeTypeObject) {
+            if ((0, types_1.isInstantiableClass)(subtype) || isSubtypeTypeObject) {
                 // Handle the special case of isinstance(x, type).
-                const includesTypeType = classTypeList.some((classType) => (0, types_2.isInstantiableClass)(classType) && types_2.ClassType.isBuiltIn(classType, 'type'));
+                const includesTypeType = classTypeList.some((classType) => (0, types_1.isInstantiableClass)(classType) && types_1.ClassType.isBuiltIn(classType, 'type'));
                 if (isPositiveTest) {
                     return includesTypeType ? negativeFallback : undefined;
                 }
@@ -1091,13 +1086,13 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             }
         }
         else {
-            if ((0, types_2.isInstantiableClass)(subtype)) {
-                return (0, types_2.combineTypes)(filterClassType(subtype, unexpandedSubtype, (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+            if ((0, types_1.isInstantiableClass)(subtype)) {
+                return (0, types_1.combineTypes)(filterClassType(subtype, unexpandedSubtype, (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
             }
             if (isSubtypeTypeObject) {
                 const objectType = evaluator.getBuiltInObject(errorNode, 'object');
-                if (objectType && (0, types_2.isClassInstance)(objectType)) {
-                    return (0, types_2.combineTypes)(filterClassType(types_2.ClassType.cloneAsInstantiable(objectType), (0, typeUtils_1.convertToInstantiable)(unexpandedSubtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+                if (objectType && (0, types_1.isClassInstance)(objectType)) {
+                    return (0, types_1.combineTypes)(filterClassType(types_1.ClassType.cloneAsInstantiable(objectType), (0, typeUtils_1.convertToInstantiable)(unexpandedSubtype), (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
                 }
             }
         }
@@ -1109,11 +1104,11 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
     // Any/Unknown. For example, if the statement is "isinstance(x, list)"
     // and the type of x is "List[str] | int | Any", the result should be
     // "List[str]", not "List[str] | List[Unknown]".
-    if ((0, types_2.isNever)(filteredType) && anyOrUnknownSubstitutions.length > 0) {
-        return (0, types_2.combineTypes)(anyOrUnknownSubstitutions);
+    if ((0, types_1.isNever)(filteredType) && anyOrUnknownSubstitutions.length > 0) {
+        return (0, types_1.combineTypes)(anyOrUnknownSubstitutions);
     }
-    if ((0, types_2.isNever)(filteredType) && anyOrUnknown.length > 0) {
-        return (0, types_2.combineTypes)(anyOrUnknown);
+    if ((0, types_1.isNever)(filteredType) && anyOrUnknown.length > 0) {
+        return (0, types_1.combineTypes)(anyOrUnknown);
     }
     return filteredType;
 }
@@ -1122,7 +1117,7 @@ function narrowTypeForTupleLength(evaluator, referenceType, lengthValue, isPosit
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         const concreteSubtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
         // If it's not a tuple, we can't narrow it.
-        if (!(0, types_2.isClassInstance)(concreteSubtype) ||
+        if (!(0, types_1.isClassInstance)(concreteSubtype) ||
             !(0, typeUtils_1.isTupleClass)(concreteSubtype) ||
             (0, typeUtils_1.isUnboundedTupleClass)(concreteSubtype) ||
             !concreteSubtype.tupleTypeArguments) {
@@ -1143,8 +1138,8 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     }
     // Narrowing in the negative case is possible only with tuples
     // with a known length.
-    if (!(0, types_2.isClassInstance)(containerType) ||
-        !types_2.ClassType.isBuiltIn(containerType, 'tuple') ||
+    if (!(0, types_1.isClassInstance)(containerType) ||
+        !types_1.ClassType.isBuiltIn(containerType, 'tuple') ||
         !containerType.tupleTypeArguments) {
         return referenceType;
     }
@@ -1153,10 +1148,10 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     const typesToEliminate = [];
     containerType.tupleTypeArguments.forEach((tupleEntry) => {
         if (!tupleEntry.isUnbounded) {
-            if ((0, types_2.isNoneInstance)(tupleEntry.type)) {
+            if ((0, types_1.isNoneInstance)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
             }
-            else if ((0, types_2.isClassInstance)(tupleEntry.type) && (0, typeUtils_1.isLiteralType)(tupleEntry.type)) {
+            else if ((0, types_1.isClassInstance)(tupleEntry.type) && (0, typeUtils_1.isLiteralType)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
             }
         }
@@ -1166,15 +1161,15 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     }
     return (0, typeUtils_1.mapSubtypes)(referenceType, (referenceSubtype) => {
         referenceSubtype = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
-        if ((0, types_2.isClassInstance)(referenceSubtype) && referenceSubtype.literalValue === undefined) {
+        if ((0, types_1.isClassInstance)(referenceSubtype) && referenceSubtype.literalValue === undefined) {
             // If we're able to enumerate all possible literal values
             // (for bool or enum), we can eliminate all others in a negative test.
             const allLiteralTypes = enumerateLiteralsForType(evaluator, referenceSubtype);
             if (allLiteralTypes && allLiteralTypes.length > 0) {
-                return (0, types_2.combineTypes)(allLiteralTypes.filter((type) => !typesToEliminate.some((t) => (0, types_2.isTypeSame)(t, type))));
+                return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !typesToEliminate.some((t) => (0, types_1.isTypeSame)(t, type))));
             }
         }
-        if (typesToEliminate.some((t) => (0, types_2.isTypeSame)(t, referenceSubtype))) {
+        if (typesToEliminate.some((t) => (0, types_1.isTypeSame)(t, referenceSubtype))) {
             return undefined;
         }
         return referenceSubtype;
@@ -1183,7 +1178,7 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
 function getElementTypeForContainerNarrowing(containerType) {
     // We support contains narrowing only for certain built-in types that have been specialized.
     const supportedContainers = ['list', 'set', 'frozenset', 'deque', 'tuple', 'dict', 'defaultdict', 'OrderedDict'];
-    if (!(0, types_2.isClassInstance)(containerType) || !types_2.ClassType.isBuiltIn(containerType, supportedContainers)) {
+    if (!(0, types_1.isClassInstance)(containerType) || !types_1.ClassType.isBuiltIn(containerType, supportedContainers)) {
         return undefined;
     }
     if (!containerType.typeArguments || containerType.typeArguments.length < 1) {
@@ -1191,7 +1186,7 @@ function getElementTypeForContainerNarrowing(containerType) {
     }
     let elementType = containerType.typeArguments[0];
     if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.tupleTypeArguments) {
-        elementType = (0, types_2.combineTypes)(containerType.tupleTypeArguments.map((t) => t.type));
+        elementType = (0, types_1.combineTypes)(containerType.tupleTypeArguments.map((t) => t.type));
     }
     return elementType;
 }
@@ -1205,12 +1200,12 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
     // narrow the reference type to "float" because it is a supertype of "int".
     const narrowedSupertypes = (0, typeUtils_1.mapSubtypes)(referenceType, (referenceSubtype) => {
         const concreteReferenceType = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
-        if ((0, types_2.isAnyOrUnknown)(concreteReferenceType)) {
+        if ((0, types_1.isAnyOrUnknown)(concreteReferenceType)) {
             canNarrow = false;
             return referenceSubtype;
         }
         // Handle "type" specially.
-        if ((0, types_2.isClassInstance)(concreteReferenceType) && types_2.ClassType.isBuiltIn(concreteReferenceType, 'type')) {
+        if ((0, types_1.isClassInstance)(concreteReferenceType) && types_1.ClassType.isBuiltIn(concreteReferenceType, 'type')) {
             canNarrow = false;
             return referenceSubtype;
         }
@@ -1219,7 +1214,7 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
         }
         if (evaluator.assignType(elementTypeWithoutLiteral, concreteReferenceType)) {
             return (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
-                if ((0, types_2.isClassInstance)(elementSubtype) && (0, types_2.isSameWithoutLiteralValue)(referenceSubtype, elementSubtype)) {
+                if ((0, types_1.isClassInstance)(elementSubtype) && (0, types_1.isSameWithoutLiteralValue)(referenceSubtype, elementSubtype)) {
                     return elementSubtype;
                 }
                 return undefined;
@@ -1234,7 +1229,7 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
     // subtypes of "object".
     const narrowedSubtypes = (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
         const concreteElementType = evaluator.makeTopLevelTypeVarsConcrete(elementSubtype);
-        if ((0, types_2.isAnyOrUnknown)(concreteElementType)) {
+        if ((0, types_1.isAnyOrUnknown)(concreteElementType)) {
             canNarrow = false;
             return referenceType;
         }
@@ -1243,14 +1238,14 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
         }
         return undefined;
     });
-    return canNarrow ? (0, types_2.combineTypes)([narrowedSupertypes, narrowedSubtypes]) : referenceType;
+    return canNarrow ? (0, types_1.combineTypes)([narrowedSupertypes, narrowedSubtypes]) : referenceType;
 }
 exports.narrowTypeForContainerElementType = narrowTypeForContainerElementType;
 // Attempts to narrow a type based on whether it is a TypedDict with
 // a literal key value.
 function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPositiveTest) {
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
-        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isTypedDictClass(subtype)) {
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
             const entries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
             const tdEntry = entries.get(literalKey.literalValue);
             if (isPositiveTest) {
@@ -1259,7 +1254,7 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
                     // the TypedDict doesn't define this entry, it is not this type.
                     // If it's not final, we can't say this because it could be a
                     // subclass of this TypedDict that adds more fields.
-                    return types_2.ClassType.isFinal(subtype) ? undefined : subtype;
+                    return types_1.ClassType.isFinal(subtype) ? undefined : subtype;
                 }
                 // If the entry is currently not required and not marked provided, we can mark
                 // it as provided after this guard expression confirms it is.
@@ -1281,7 +1276,7 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
                     isProvided: true,
                 });
                 // Clone the TypedDict object with the new entries.
-                return types_2.ClassType.cloneAsInstance(types_2.ClassType.cloneForNarrowedTypedDictEntries(types_2.ClassType.cloneAsInstantiable(subtype), newNarrowedEntriesMap));
+                return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForNarrowedTypedDictEntries(types_1.ClassType.cloneAsInstantiable(subtype), newNarrowedEntriesMap));
             }
             else {
                 return tdEntry !== undefined && (tdEntry.isRequired || tdEntry.isProvided) ? undefined : subtype;
@@ -1297,7 +1292,7 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
 function narrowTypeForDiscriminatedDictEntryComparison(evaluator, referenceType, indexLiteralType, literalType, isPositiveTest) {
     let canNarrow = true;
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
-        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isTypedDictClass(subtype)) {
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
             const symbolMap = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype);
             const tdEntry = symbolMap.get(indexLiteralType.literalValue);
             if (tdEntry && (0, typeUtils_1.isLiteralTypeOrUnion)(tdEntry.valueType)) {
@@ -1314,12 +1309,13 @@ function narrowTypeForDiscriminatedDictEntryComparison(evaluator, referenceType,
     });
     return canNarrow ? narrowedType : referenceType;
 }
+exports.narrowTypeForDiscriminatedDictEntryComparison = narrowTypeForDiscriminatedDictEntryComparison;
 function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, indexLiteralType, literalType, isPositiveTest) {
     let canNarrow = true;
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         var _a;
-        if ((0, types_2.isClassInstance)(subtype) &&
-            types_2.ClassType.isTupleClass(subtype) &&
+        if ((0, types_1.isClassInstance)(subtype) &&
+            types_1.ClassType.isTupleClass(subtype) &&
             !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
             typeof indexLiteralType.literalValue === 'number') {
             const indexValue = indexLiteralType.literalValue;
@@ -1340,28 +1336,29 @@ function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, ind
     });
     return canNarrow ? narrowedType : referenceType;
 }
+exports.narrowTypeForDiscriminatedTupleComparison = narrowTypeForDiscriminatedTupleComparison;
 // Attempts to narrow a type based on a comparison (equal or not equal)
 // between a discriminating field that has a declared literal type to a
 // literal value.
 function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceType, memberName, literalType, isPositiveTest) {
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         let memberInfo;
-        if ((0, types_2.isClassInstance)(subtype)) {
+        if ((0, types_1.isClassInstance)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
         }
-        else if ((0, types_2.isInstantiableClass)(subtype)) {
+        else if ((0, types_1.isInstantiableClass)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
         }
         if (memberInfo && memberInfo.isTypeDeclared) {
             let memberType = evaluator.getTypeOfMember(memberInfo);
             // Handle the case where the field is a property
             // that has a declared literal return type for its getter.
-            if ((0, types_2.isClassInstance)(subtype) && (0, typeUtils_1.isProperty)(memberType)) {
+            if ((0, types_1.isClassInstance)(subtype) && (0, typeUtils_1.isProperty)(memberType)) {
                 const getterInfo = (0, typeUtils_1.lookUpObjectMember)(memberType, 'fget');
                 if (getterInfo && getterInfo.isTypeDeclared) {
                     const getterType = evaluator.getTypeOfMember(getterInfo);
-                    if ((0, types_2.isFunction)(getterType) && getterType.details.declaredReturnType) {
-                        const getterReturnType = types_2.FunctionType.getSpecializedReturnType(getterType);
+                    if ((0, types_1.isFunction)(getterType) && getterType.details.declaredReturnType) {
+                        const getterReturnType = types_1.FunctionType.getSpecializedReturnType(getterType);
                         if (getterReturnType) {
                             memberType = getterReturnType;
                         }
@@ -1387,10 +1384,10 @@ function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceTy
 function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType, memberName, isPositiveTest) {
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         let memberInfo;
-        if ((0, types_2.isClassInstance)(subtype)) {
+        if ((0, types_1.isClassInstance)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
         }
-        else if ((0, types_2.isInstantiableClass)(subtype)) {
+        else if ((0, types_1.isInstantiableClass)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
         }
         if (memberInfo && memberInfo.isTypeDeclared) {
@@ -1403,13 +1400,13 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
                     if ((0, typeUtils_1.isProperty)(memberSubtype) || (0, typeUtils_1.isMaybeDescriptorInstance)(memberSubtype)) {
                         canNarrow = false;
                     }
-                    if ((0, types_2.isAnyOrUnknown)(memberSubtype) || (0, types_2.isNoneInstance)(memberSubtype) || (0, types_2.isNever)(memberSubtype)) {
+                    if ((0, types_1.isAnyOrUnknown)(memberSubtype) || (0, types_1.isNoneInstance)(memberSubtype) || (0, types_1.isNever)(memberSubtype)) {
                         canNarrow = false;
                     }
                 });
             }
             else {
-                canNarrow = (0, types_2.isNoneInstance)(memberType);
+                canNarrow = (0, types_1.isNoneInstance)(memberType);
             }
             if (canNarrow) {
                 return undefined;
@@ -1422,21 +1419,21 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
 function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
     return evaluator.mapSubtypesExpandTypeVars(type, 
     /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
-        if ((0, types_2.isClassInstance)(subtype)) {
-            const matches = types_2.ClassType.isDerivedFrom(classType, types_2.ClassType.cloneAsInstantiable(subtype));
+        if ((0, types_1.isClassInstance)(subtype)) {
+            const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
             if (isPositiveTest) {
                 if (matches) {
-                    if (types_2.ClassType.isSameGenericClass(subtype, classType)) {
+                    if (types_1.ClassType.isSameGenericClass(subtype, classType)) {
                         return subtype;
                     }
-                    return (0, typeUtils_1.addConditionToType)(types_2.ClassType.cloneAsInstance(classType), subtype.condition);
+                    return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), subtype.condition);
                 }
                 return undefined;
             }
             else {
                 // If the class if marked final and it matches, then
                 // we can eliminate it in the negative case.
-                if (matches && types_2.ClassType.isFinal(subtype)) {
+                if (matches && types_1.ClassType.isFinal(subtype)) {
                     return undefined;
                 }
                 // We can't eliminate the subtype in the negative
@@ -1445,11 +1442,11 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
                 return subtype;
             }
         }
-        else if ((0, types_2.isNoneInstance)(subtype)) {
+        else if ((0, types_1.isNoneInstance)(subtype)) {
             return isPositiveTest ? undefined : subtype;
         }
-        else if ((0, types_2.isAnyOrUnknown)(subtype)) {
-            return isPositiveTest ? types_2.ClassType.cloneAsInstance(classType) : subtype;
+        else if ((0, types_1.isAnyOrUnknown)(subtype)) {
+            return isPositiveTest ? types_1.ClassType.cloneAsInstance(classType) : subtype;
         }
         return unexpandedSubtype;
     });
@@ -1460,9 +1457,9 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
 function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, isPositiveTest, isIsOperator) {
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         subtype = evaluator.makeTopLevelTypeVarsConcrete(subtype);
-        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isSameGenericClass(literalType, subtype)) {
+        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
             if (subtype.literalValue !== undefined) {
-                const literalValueMatches = types_2.ClassType.isLiteralValueSame(subtype, literalType);
+                const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
                 if ((literalValueMatches && !isPositiveTest) || (!literalValueMatches && isPositiveTest)) {
                     return undefined;
                 }
@@ -1476,12 +1473,12 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
                 // (for bool or enum), we can eliminate all others in a negative test.
                 const allLiteralTypes = enumerateLiteralsForType(evaluator, subtype);
                 if (allLiteralTypes && allLiteralTypes.length > 0) {
-                    return (0, types_2.combineTypes)(allLiteralTypes.filter((type) => !types_2.ClassType.isLiteralValueSame(type, literalType)));
+                    return (0, types_1.combineTypes)(allLiteralTypes.filter((type) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
                 }
             }
         }
         else if (isPositiveTest) {
-            if (isIsOperator || (0, types_2.isNoneInstance)(subtype)) {
+            if (isIsOperator || (0, types_1.isNoneInstance)(subtype)) {
                 return undefined;
             }
         }
@@ -1489,22 +1486,22 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
     });
 }
 function enumerateLiteralsForType(evaluator, type) {
-    if (types_2.ClassType.isBuiltIn(type, 'bool')) {
+    if (types_1.ClassType.isBuiltIn(type, 'bool')) {
         // Booleans have only two types: True and False.
         return [
-            types_2.ClassType.cloneWithLiteral(type, /* value */ true),
-            types_2.ClassType.cloneWithLiteral(type, /* value */ false),
+            types_1.ClassType.cloneWithLiteral(type, /* value */ true),
+            types_1.ClassType.cloneWithLiteral(type, /* value */ false),
         ];
     }
-    if (types_2.ClassType.isEnumClass(type)) {
+    if (types_1.ClassType.isEnumClass(type)) {
         // Enumerate all of the values in this enumeration.
         const enumList = [];
         const fields = type.details.fields;
         fields.forEach((symbol) => {
             if (!symbol.isIgnoredForProtocolMatch()) {
                 const symbolType = evaluator.getEffectiveTypeOfSymbol(symbol);
-                if ((0, types_2.isClassInstance)(symbolType) &&
-                    types_2.ClassType.isSameGenericClass(type, symbolType) &&
+                if ((0, types_1.isClassInstance)(symbolType) &&
+                    types_1.ClassType.isSameGenericClass(type, symbolType) &&
                     symbolType.literalValue !== undefined) {
                     enumList.push(symbolType);
                 }
@@ -1531,7 +1528,7 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                 return isPositiveTest ? undefined : subtype;
             }
             case 7 /* Class */: {
-                if (types_2.TypeBase.isInstantiable(subtype)) {
+                if (types_1.TypeBase.isInstantiable(subtype)) {
                     return isPositiveTest ? subtype : undefined;
                 }
                 // See if the object is callable.
@@ -1546,24 +1543,24 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                         // new intersection type.
                         const className = `<callable subtype of ${subtype.details.name}>`;
                         const fileInfo = (0, analyzerNodeInfo_1.getFileInfo)(errorNode);
-                        let newClassType = types_2.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        let newClassType = types_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
                         /* declaredMetaclass */ undefined, subtype.details.effectiveMetaclass, subtype.details.docString);
-                        newClassType.details.baseClasses = [types_2.ClassType.cloneAsInstantiable(subtype)];
+                        newClassType.details.baseClasses = [types_1.ClassType.cloneAsInstantiable(subtype)];
                         (0, typeUtils_1.computeMroLinearization)(newClassType);
                         newClassType = (0, typeUtils_1.addConditionToType)(newClassType, subtype.condition);
                         // Add a __call__ method to the new class.
-                        const callMethod = types_2.FunctionType.createSynthesizedInstance('__call__');
+                        const callMethod = types_1.FunctionType.createSynthesizedInstance('__call__');
                         const selfParam = {
                             category: 0 /* Simple */,
                             name: 'self',
-                            type: types_2.ClassType.cloneAsInstance(newClassType),
+                            type: types_1.ClassType.cloneAsInstance(newClassType),
                             hasDeclaredType: true,
                         };
-                        types_2.FunctionType.addParameter(callMethod, selfParam);
-                        types_2.FunctionType.addDefaultParameters(callMethod);
-                        callMethod.details.declaredReturnType = types_2.UnknownType.create();
+                        types_1.FunctionType.addParameter(callMethod, selfParam);
+                        types_1.FunctionType.addDefaultParameters(callMethod);
+                        callMethod.details.declaredReturnType = types_1.UnknownType.create();
                         newClassType.details.fields.set('__call__', symbol_1.Symbol.createWithType(4 /* ClassMember */, callMethod));
-                        return types_2.ClassType.cloneAsInstance(newClassType);
+                        return types_1.ClassType.cloneAsInstance(newClassType);
                     }
                     return undefined;
                 }