@zzzen/pyright-internal 1.2.0-dev.20230326 → 1.2.0-dev.20230402

package/dist/analyzer/typeGuards.js

@@ -38,6 +38,7 @@ 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
@@ -45,7 +46,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_1.maxTypeRecursionCount) {
+    if (recursionCount > types_2.maxTypeRecursionCount) {
         return undefined;
     }
     recursionCount++;
@@ -119,10 +120,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_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'type')) {
+                        if ((0, types_2.isInstantiableClass)(callType) && types_2.ClassType.isBuiltIn(callType, 'type')) {
                             const classTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                             const classType = evaluator.makeTopLevelTypeVarsConcrete(classTypeResult.type);
-                            if ((0, types_1.isInstantiableClass)(classType)) {
+                            if ((0, types_2.isInstantiableClass)(classType)) {
                                 return (type) => {
                                     return {
                                         type: narrowTypeForTypeIs(evaluator, type, classType, adjIsPositiveTest),
@@ -139,8 +140,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_1.isClassInstance)(rightType) &&
-                        (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
+                    if ((0, types_2.isClassInstance)(rightType) &&
+                        (types_2.ClassType.isEnumClass(rightType) || types_2.ClassType.isBuiltIn(rightType, 'bool')) &&
                         rightType.literalValue !== undefined) {
                         return (type) => {
                             return {
@@ -159,10 +160,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_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
-                        if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
+                    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_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 return (type) => {
                                     return {
                                         type: narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
@@ -171,6 +172,28 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                                 };
                             }
                         }
+                        else if (types_2.ClassType.isBuiltIn(indexType, 'int')) {
+                            const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
+                            const rightType = rightTypeResult.type;
+                            if ((0, types_2.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')) {
+                                    canNarrow = true;
+                                }
+                                else if (rightType.literalValue instanceof types_1.EnumLiteral) {
+                                    canNarrow = true;
+                                }
+                                if (canNarrow) {
+                                    return (type) => {
+                                        return {
+                                            type: narrowTypeForDiscriminatedTupleComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
+                                            isIncomplete: !!rightTypeResult.isIncomplete,
+                                        };
+                                    };
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -180,7 +203,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_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                    if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                         return (type) => {
                             return {
                                 type: narrowTypeForLiteralComparison(evaluator, type, rightType, adjIsPositiveTest, 
@@ -198,10 +221,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_1.isClassInstance)(indexType) && (0, typeUtils_1.isLiteralType)(indexType)) {
-                        if (types_1.ClassType.isBuiltIn(indexType, 'str')) {
+                    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_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 return (type) => {
                                     return {
                                         type: narrowTypeForDiscriminatedDictEntryComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
@@ -210,10 +233,10 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                                 };
                             }
                         }
-                        else if (types_1.ClassType.isBuiltIn(indexType, 'int')) {
+                        else if (types_2.ClassType.isBuiltIn(indexType, 'int')) {
                             const rightTypeResult = evaluator.getTypeOfExpression(testExpression.rightExpression);
                             const rightType = rightTypeResult.type;
-                            if ((0, types_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                            if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                                 return (type) => {
                                     return {
                                         type: narrowTypeForDiscriminatedTupleComparison(evaluator, type, indexType, rightType, adjIsPositiveTest),
@@ -235,7 +258,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_1.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
+                    if ((0, types_2.isFunction)(callType) && callType.details.fullName === 'builtins.len') {
                         const tupleLength = testExpression.rightExpression.value;
                         if (typeof tupleLength === 'number') {
                             return (type) => {
@@ -255,7 +278,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_1.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
+                if ((0, types_2.isClassInstance)(rightType) && rightType.literalValue !== undefined) {
                     return (type) => {
                         return {
                             type: narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, type, memberName.value, rightType, adjIsPositiveTest),
@@ -271,8 +294,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_1.isClassInstance)(rightType) &&
-                    (types_1.ClassType.isEnumClass(rightType) || types_1.ClassType.isBuiltIn(rightType, 'bool')) &&
+                if ((0, types_2.isClassInstance)(rightType) &&
+                    (types_2.ClassType.isEnumClass(rightType) || types_2.ClassType.isBuiltIn(rightType, 'bool')) &&
                     rightType.literalValue !== undefined) {
                     return (type) => {
                         return {
@@ -315,11 +338,11 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 // one or more TypedDicts.
                 const leftTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression);
                 const leftType = leftTypeResult.type;
-                if ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'str') && (0, typeUtils_1.isLiteralType)(leftType)) {
+                if ((0, types_2.isClassInstance)(leftType) && types_2.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_1.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
+                            type: narrowTypeForTypedDictKey(evaluator, type, types_2.ClassType.cloneAsInstantiable(leftType), adjIsPositiveTest),
                             isIncomplete: !!leftTypeResult.isIncomplete,
                         };
                     };
@@ -338,7 +361,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_1.isFunction)(callType) &&
+                if ((0, types_2.isFunction)(callType) &&
                     (callType.details.builtInName === 'isinstance' || callType.details.builtInName === 'issubclass')) {
                     const isInstanceCheck = callType.details.builtInName === 'isinstance';
                     const arg1TypeResult = evaluator.getTypeOfExpression(arg1Expr, 8 /* EvaluateStringLiteralAsType */ |
@@ -351,7 +374,7 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                         return (type) => {
                             const narrowedType = narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck, isPositiveTest, 
                             /* allowIntersections */ false, testExpression);
-                            if (!(0, types_1.isNever)(narrowedType)) {
+                            if (!(0, types_2.isNever)(narrowedType)) {
                                 return {
                                     type: narrowedType,
                                     isIncomplete,
@@ -384,11 +407,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_1.isFunction)(callType) && callType.details.builtInName === 'callable') {
+                if ((0, types_2.isFunction)(callType) && callType.details.builtInName === 'callable') {
                     return (type) => {
                         let narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
                         /* allowIntersections */ false);
-                        if (isPositiveTest && (0, types_1.isNever)(narrowedType)) {
+                        if (isPositiveTest && (0, types_2.isNever)(narrowedType)) {
                             // Try again with intersections allowed.
                             narrowedType = narrowTypeForCallable(evaluator, type, isPositiveTest, testExpression, 
                             /* allowIntersections */ true);
@@ -403,7 +426,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_1.isInstantiableClass)(callType) && types_1.ClassType.isBuiltIn(callType, 'bool')) {
+                if ((0, types_2.isInstantiableClass)(callType) && types_2.ClassType.isBuiltIn(callType, 'bool')) {
                     return (type) => {
                         return {
                             type: narrowTypeForTruthiness(evaluator, type, isPositiveTest),
@@ -421,27 +444,27 @@ function getTypeNarrowingCallback(evaluator, reference, testExpression, isPositi
                 let isPossiblyTypeGuard = false;
                 const isFunctionReturnTypeGuard = (type) => {
                     return (type.details.declaredReturnType &&
-                        (0, types_1.isClassInstance)(type.details.declaredReturnType) &&
-                        types_1.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'StrictTypeGuard']));
+                        (0, types_2.isClassInstance)(type.details.declaredReturnType) &&
+                        types_2.ClassType.isBuiltIn(type.details.declaredReturnType, ['TypeGuard', 'StrictTypeGuard']));
                 };
                 const callTypeResult = evaluator.getTypeOfExpression(testExpression.leftExpression, 2 /* DoNotSpecialize */);
                 const callType = callTypeResult.type;
-                if ((0, types_1.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
+                if ((0, types_2.isFunction)(callType) && isFunctionReturnTypeGuard(callType)) {
                     isPossiblyTypeGuard = true;
                 }
-                else if ((0, types_1.isOverloadedFunction)(callType) &&
-                    types_1.OverloadedFunctionType.getOverloads(callType).some((o) => isFunctionReturnTypeGuard(o))) {
+                else if ((0, types_2.isOverloadedFunction)(callType) &&
+                    types_2.OverloadedFunctionType.getOverloads(callType).some((o) => isFunctionReturnTypeGuard(o))) {
                     isPossiblyTypeGuard = true;
                 }
-                else if ((0, types_1.isClassInstance)(callType)) {
+                else if ((0, types_2.isClassInstance)(callType)) {
                     isPossiblyTypeGuard = true;
                 }
                 if (isPossiblyTypeGuard) {
                     // Evaluate the type guard call expression.
                     const functionReturnTypeResult = evaluator.getTypeOfExpression(testExpression);
                     const functionReturnType = functionReturnTypeResult.type;
-                    if ((0, types_1.isClassInstance)(functionReturnType) &&
-                        types_1.ClassType.isBuiltIn(functionReturnType, 'bool') &&
+                    if ((0, types_2.isClassInstance)(functionReturnType) &&
+                        types_2.ClassType.isBuiltIn(functionReturnType, 'bool') &&
                         functionReturnType.typeGuardType) {
                         const isStrictTypeGuard = !!functionReturnType.isStrictTypeGuard;
                         const typeGuardType = functionReturnType.typeGuardType;
@@ -625,12 +648,12 @@ function narrowTupleTypeForIsNone(evaluator, type, isPositiveTest, indexValue) {
         }
         const typeOfEntry = evaluator.makeTopLevelTypeVarsConcrete(tupleType.tupleTypeArguments[indexValue].type);
         if (isPositiveTest) {
-            if (!evaluator.assignType(typeOfEntry, types_1.NoneType.createInstance())) {
+            if (!evaluator.assignType(typeOfEntry, types_2.NoneType.createInstance())) {
                 return undefined;
             }
         }
         else {
-            if ((0, types_1.isNoneInstance)(typeOfEntry)) {
+            if ((0, types_2.isNoneInstance)(typeOfEntry)) {
                 return undefined;
             }
         }
@@ -644,7 +667,7 @@ function narrowTypeForIsNone(evaluator, type, isPositiveTest) {
     });
     return evaluator.mapSubtypesExpandTypeVars(expandedType, 
     /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
-        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+        if ((0, types_2.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;
@@ -652,17 +675,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_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+        const adjustedSubtype = (0, types_2.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
             ? unexpandedSubtype
             : subtype;
         // See if it's a match for object.
-        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
+        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'object')) {
             return isPositiveTest
-                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
+                ? (0, typeUtils_1.addConditionToType)(types_2.NoneType.createInstance(), subtype.condition)
                 : adjustedSubtype;
         }
         // See if it's a match for None.
-        if ((0, types_1.isNoneInstance)(subtype) === isPositiveTest) {
+        if ((0, types_2.isNoneInstance)(subtype) === isPositiveTest) {
             return subtype;
         }
         return undefined;
@@ -675,7 +698,7 @@ function narrowTypeForIsEllipsis(evaluator, type, isPositiveTest) {
     });
     return evaluator.mapSubtypesExpandTypeVars(expandedType, 
     /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
-        if ((0, types_1.isAnyOrUnknown)(subtype)) {
+        if ((0, types_2.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;
@@ -683,16 +706,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_1.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
+        const adjustedSubtype = (0, types_2.isTypeVar)(unexpandedSubtype) && unexpandedSubtype.details.constraints.length === 0
             ? unexpandedSubtype
             : subtype;
         // See if it's a match for object.
-        if ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'object')) {
+        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'object')) {
             return isPositiveTest
-                ? (0, typeUtils_1.addConditionToType)(types_1.NoneType.createInstance(), subtype.condition)
+                ? (0, typeUtils_1.addConditionToType)(types_2.NoneType.createInstance(), subtype.condition)
                 : adjustedSubtype;
         }
-        const isEllipsis = (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'ellipsis');
+        const isEllipsis = (0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'ellipsis');
         // See if it's a match for "...".
         if (isEllipsis === isPositiveTest) {
             return subtype;
@@ -711,13 +734,13 @@ function getIsInstanceClassTypes(argType) {
     // undefined if any of the types are not valid.
     const addClassTypesToList = (types) => {
         types.forEach((subtype) => {
-            if ((0, types_1.isInstantiableClass)(subtype) || ((0, types_1.isTypeVar)(subtype) && types_1.TypeBase.isInstantiable(subtype))) {
+            if ((0, types_2.isInstantiableClass)(subtype) || ((0, types_2.isTypeVar)(subtype) && types_2.TypeBase.isInstantiable(subtype))) {
                 classTypeList.push(subtype);
             }
-            else if ((0, types_1.isNoneTypeClass)(subtype)) {
+            else if ((0, types_2.isNoneTypeClass)(subtype)) {
                 classTypeList.push(subtype);
             }
-            else if ((0, types_1.isFunction)(subtype) &&
+            else if ((0, types_2.isFunction)(subtype) &&
                 subtype.details.parameters.length === 2 &&
                 subtype.details.parameters[0].category === 1 /* VarArgList */ &&
                 subtype.details.parameters[1].category === 2 /* VarArgDictionary */) {
@@ -729,10 +752,10 @@ function getIsInstanceClassTypes(argType) {
         });
     };
     const addClassTypesRecursive = (subtype, recursionCount = 0) => {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
+        if (recursionCount > types_2.maxTypeRecursionCount) {
             return;
         }
-        if ((0, types_1.isClass)(subtype) && types_1.TypeBase.isInstance(subtype) && (0, typeUtils_1.isTupleClass)(subtype)) {
+        if ((0, types_2.isClass)(subtype) && types_2.TypeBase.isInstance(subtype) && (0, typeUtils_1.isTupleClass)(subtype)) {
             if (subtype.tupleTypeArguments) {
                 subtype.tupleTypeArguments.forEach((tupleEntry) => {
                     addClassTypesRecursive(tupleEntry.type, recursionCount + 1);
@@ -755,32 +778,32 @@ function isIsinstanceFilterSuperclass(evaluator, varType, filterType, concreteFi
     if (concreteFilterType.includeSubclasses) {
         return false;
     }
-    if ((0, types_1.isTypeVar)(filterType)) {
+    if ((0, types_2.isTypeVar)(filterType)) {
         return false;
     }
-    if (types_1.ClassType.isDerivedFrom(varType, concreteFilterType)) {
+    if (types_2.ClassType.isDerivedFrom(varType, concreteFilterType)) {
         return true;
     }
     if (isInstanceCheck) {
-        if (types_1.ClassType.isProtocolClass(concreteFilterType) && evaluator.assignType(concreteFilterType, varType)) {
+        if (types_2.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_1.ClassType.isBuiltIn(concreteFilterType, 'dict') && types_1.ClassType.isTypedDictClass(varType)) {
+    if (types_2.ClassType.isBuiltIn(concreteFilterType, 'dict') && types_2.ClassType.isTypedDictClass(varType)) {
         return true;
     }
     return false;
 }
 exports.isIsinstanceFilterSuperclass = isIsinstanceFilterSuperclass;
 function isIsinstanceFilterSubclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck) {
-    if (types_1.ClassType.isDerivedFrom(concreteFilterType, varType)) {
+    if (types_2.ClassType.isDerivedFrom(concreteFilterType, varType)) {
         return true;
     }
     if (isInstanceCheck) {
-        if (types_1.ClassType.isProtocolClass(varType) && evaluator.assignType(varType, concreteFilterType)) {
+        if (types_2.ClassType.isProtocolClass(varType) && evaluator.assignType(varType, concreteFilterType)) {
             return true;
         }
     }
@@ -805,7 +828,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
         let isClassRelationshipIndeterminate = false;
         for (const filterType of classTypeList) {
             const concreteFilterType = evaluator.makeTopLevelTypeVarsConcrete(filterType);
-            if ((0, types_1.isInstantiableClass)(concreteFilterType)) {
+            if ((0, types_2.isInstantiableClass)(concreteFilterType)) {
                 const filterIsSuperclass = isIsinstanceFilterSuperclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck);
                 const filterIsSubclass = isIsinstanceFilterSubclass(evaluator, varType, filterType, concreteFilterType, isInstanceCheck);
                 if (filterIsSuperclass) {
@@ -818,7 +841,7 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                 // will generate false positives.
                 if (filterIsSubclass &&
                     filterIsSuperclass &&
-                    !types_1.ClassType.isSameGenericClass(varType, concreteFilterType)) {
+                    !types_2.ClassType.isSameGenericClass(varType, concreteFilterType)) {
                     isClassRelationshipIndeterminate = true;
                 }
                 if (isPositiveTest) {
@@ -834,11 +857,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_1.isClass)(filterType)) {
-                            if (types_1.ClassType.isSpecialBuiltIn(filterType) ||
+                        if ((0, types_2.isClass)(filterType)) {
+                            if (types_2.ClassType.isSpecialBuiltIn(filterType) ||
                                 filterType.details.typeParameters.length > 0) {
                                 const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(filterType));
-                                const unspecializedFilterType = types_1.ClassType.cloneForSpecialization(filterType, 
+                                const unspecializedFilterType = types_2.ClassType.cloneForSpecialization(filterType, 
                                 /* typeArguments */ undefined, 
                                 /* isTypeArgumentExplicit */ false);
                                 if ((0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluator, unspecializedFilterType, varType, typeVarContext, 
@@ -857,38 +880,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_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        let newClassType = types_2.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_1.ClassType.cloneAsInstantiable(varType), concreteFilterType];
+                        newClassType.details.baseClasses = [types_2.ClassType.cloneAsInstantiable(varType), concreteFilterType];
                         (0, typeUtils_1.computeMroLinearization)(newClassType);
                         newClassType = (0, typeUtils_1.addConditionToType)(newClassType, concreteFilterType.condition);
-                        if ((0, types_1.isTypeVar)(unexpandedType) &&
+                        if ((0, types_2.isTypeVar)(unexpandedType) &&
                             !unexpandedType.details.isParamSpec &&
                             unexpandedType.details.constraints.length === 0) {
                             newClassType = (0, typeUtils_1.addConditionToType)(newClassType, [
                                 {
-                                    typeVarName: types_1.TypeVarType.getNameWithScope(unexpandedType),
+                                    typeVarName: types_2.TypeVarType.getNameWithScope(unexpandedType),
                                     constraintIndex: 0,
                                     isConstrainedTypeVar: false,
                                 },
                             ]);
                         }
-                        let newClassInstanceType = types_1.ClassType.cloneAsInstance(newClassType);
+                        let newClassInstanceType = types_2.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_1.ClassType.cloneAsInstantiable(newClassInstanceType));
+                        filteredTypes.push(isInstanceCheck ? newClassInstanceType : types_2.ClassType.cloneAsInstantiable(newClassInstanceType));
                     }
                 }
             }
-            else if ((0, types_1.isTypeVar)(filterType) && types_1.TypeBase.isInstantiable(filterType)) {
+            else if ((0, types_2.isTypeVar)(filterType) && types_2.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_1.TypeBase.isInstance(unexpandedType)) {
-                    if ((0, types_1.isTypeVar)(unexpandedType) && (0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(filterType), unexpandedType)) {
+                if (isInstanceCheck && types_2.TypeBase.isInstance(unexpandedType)) {
+                    if ((0, types_2.isTypeVar)(unexpandedType) && (0, types_2.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) {
@@ -907,8 +930,8 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                         }
                     }
                 }
-                else if (!isInstanceCheck && types_1.TypeBase.isInstantiable(unexpandedType)) {
-                    if ((0, types_1.isTypeVar)(unexpandedType) && (0, types_1.isTypeSame)(filterType, unexpandedType)) {
+                else if (!isInstanceCheck && types_2.TypeBase.isInstantiable(unexpandedType)) {
+                    if ((0, types_2.isTypeVar)(unexpandedType) && (0, types_2.isTypeSame)(filterType, unexpandedType)) {
                         if (isPositiveTest) {
                             filteredTypes.push(unexpandedType);
                         }
@@ -924,12 +947,12 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                     }
                 }
             }
-            else if ((0, types_1.isFunction)(filterType)) {
+            else if ((0, types_2.isFunction)(filterType)) {
                 // Handle an isinstance check against Callable.
                 if (isInstanceCheck) {
                     let isCallable = false;
-                    if ((0, types_1.isClass)(varType)) {
-                        if (types_1.TypeBase.isInstantiable(unexpandedType)) {
+                    if ((0, types_2.isClass)(varType)) {
+                        if (types_2.TypeBase.isInstantiable(unexpandedType)) {
                             isCallable = true;
                         }
                         else {
@@ -961,7 +984,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_1.isInstantiableClass)(t) ? (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(t)) : t));
+            return filteredTypes.map((t) => ((0, types_2.isInstantiableClass)(t) ? (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(t)) : t));
         }
         return filteredTypes.map((t) => (0, typeUtils_1.convertToInstance)(t));
     };
@@ -973,7 +996,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_1.isFunction)(filterType)) {
+                    if ((0, types_2.isFunction)(filterType)) {
                         filteredTypes.push(unexpandedType);
                     }
                     else {
@@ -986,7 +1009,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_1.isClass)(concreteFilterType) && !types_1.ClassType.isProtocolClass(concreteFilterType)) {
+            if ((0, types_2.isClass)(concreteFilterType) && !types_2.ClassType.isProtocolClass(concreteFilterType)) {
                 return false;
             }
             return evaluator.assignType(varType, (0, typeUtils_1.convertToInstance)(concreteFilterType));
@@ -1005,30 +1028,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_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'type');
-        if (isPositiveTest && (0, types_1.isAnyOrUnknown)(subtype)) {
+        const isSubtypeTypeObject = (0, types_2.isClassInstance)(subtype) && types_2.ClassType.isBuiltIn(subtype, 'type');
+        if (isPositiveTest && (0, types_2.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_1.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstance)(classType))));
+                anyOrUnknownSubstitutions.push((0, types_2.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_1.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(classType)))));
+                anyOrUnknownSubstitutions.push((0, types_2.combineTypes)(classTypeList.map((classType) => (0, typeUtils_1.convertToInstantiable)((0, typeUtils_1.convertToInstance)(classType)))));
             }
             anyOrUnknown.push(subtype);
             return undefined;
         }
         if (isInstanceCheck) {
-            if ((0, types_1.isNoneInstance)(subtype)) {
+            if ((0, types_2.isNoneInstance)(subtype)) {
                 const containsNoneType = classTypeList.some((t) => {
-                    if ((0, types_1.isNoneTypeClass)(t)) {
+                    if ((0, types_2.isNoneTypeClass)(t)) {
                         return true;
                     }
-                    return (0, types_1.isInstantiableClass)(t) && types_1.ClassType.isBuiltIn(t, 'NoneType');
+                    return (0, types_2.isInstantiableClass)(t) && types_2.ClassType.isBuiltIn(t, 'NoneType');
                 });
                 if (isPositiveTest) {
                     return containsNoneType ? subtype : undefined;
@@ -1037,28 +1060,28 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
                     return containsNoneType ? undefined : subtype;
                 }
             }
-            if ((0, types_1.isModule)(subtype) || ((0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, 'ModuleType'))) {
+            if ((0, types_2.isModule)(subtype) || ((0, types_2.isClassInstance)(subtype) && types_2.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_1.isInstantiableClass)(concreteClassType) && types_1.ClassType.isProtocolClass(concreteClassType));
+                        return ((0, types_2.isInstantiableClass)(concreteClassType) && types_2.ClassType.isProtocolClass(concreteClassType));
                     });
                     if (filteredTypes.length > 0) {
-                        return (0, typeUtils_1.convertToInstance)((0, types_1.combineTypes)(filteredTypes));
+                        return (0, typeUtils_1.convertToInstance)((0, types_2.combineTypes)(filteredTypes));
                     }
                 }
             }
-            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.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.isFunction)(subtype) || (0, types_1.isOverloadedFunction)(subtype)) && isInstanceCheck) {
-                return (0, types_1.combineTypes)(filterFunctionType(subtype, (0, typeUtils_1.convertToInstance)(unexpandedSubtype)));
+            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.isInstantiableClass)(subtype) || isSubtypeTypeObject) {
+            if ((0, types_2.isInstantiableClass)(subtype) || isSubtypeTypeObject) {
                 // Handle the special case of isinstance(x, type).
-                const includesTypeType = classTypeList.some((classType) => (0, types_1.isInstantiableClass)(classType) && types_1.ClassType.isBuiltIn(classType, 'type'));
+                const includesTypeType = classTypeList.some((classType) => (0, types_2.isInstantiableClass)(classType) && types_2.ClassType.isBuiltIn(classType, 'type'));
                 if (isPositiveTest) {
                     return includesTypeType ? negativeFallback : undefined;
                 }
@@ -1068,13 +1091,13 @@ function narrowTypeForIsInstance(evaluator, type, classTypeList, isInstanceCheck
             }
         }
         else {
-            if ((0, types_1.isInstantiableClass)(subtype)) {
-                return (0, types_1.combineTypes)(filterClassType(subtype, unexpandedSubtype, (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
+            if ((0, types_2.isInstantiableClass)(subtype)) {
+                return (0, types_2.combineTypes)(filterClassType(subtype, unexpandedSubtype, (0, typeUtils_1.getTypeCondition)(subtype), negativeFallback));
             }
             if (isSubtypeTypeObject) {
                 const objectType = evaluator.getBuiltInObject(errorNode, 'object');
-                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));
+                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));
                 }
             }
         }
@@ -1086,11 +1109,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_1.isNever)(filteredType) && anyOrUnknownSubstitutions.length > 0) {
-        return (0, types_1.combineTypes)(anyOrUnknownSubstitutions);
+    if ((0, types_2.isNever)(filteredType) && anyOrUnknownSubstitutions.length > 0) {
+        return (0, types_2.combineTypes)(anyOrUnknownSubstitutions);
     }
-    if ((0, types_1.isNever)(filteredType) && anyOrUnknown.length > 0) {
-        return (0, types_1.combineTypes)(anyOrUnknown);
+    if ((0, types_2.isNever)(filteredType) && anyOrUnknown.length > 0) {
+        return (0, types_2.combineTypes)(anyOrUnknown);
     }
     return filteredType;
 }
@@ -1099,7 +1122,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_1.isClassInstance)(concreteSubtype) ||
+        if (!(0, types_2.isClassInstance)(concreteSubtype) ||
             !(0, typeUtils_1.isTupleClass)(concreteSubtype) ||
             (0, typeUtils_1.isUnboundedTupleClass)(concreteSubtype) ||
             !concreteSubtype.tupleTypeArguments) {
@@ -1120,8 +1143,8 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     }
     // Narrowing in the negative case is possible only with tuples
     // with a known length.
-    if (!(0, types_1.isClassInstance)(containerType) ||
-        !types_1.ClassType.isBuiltIn(containerType, 'tuple') ||
+    if (!(0, types_2.isClassInstance)(containerType) ||
+        !types_2.ClassType.isBuiltIn(containerType, 'tuple') ||
         !containerType.tupleTypeArguments) {
         return referenceType;
     }
@@ -1130,10 +1153,10 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     const typesToEliminate = [];
     containerType.tupleTypeArguments.forEach((tupleEntry) => {
         if (!tupleEntry.isUnbounded) {
-            if ((0, types_1.isNoneInstance)(tupleEntry.type)) {
+            if ((0, types_2.isNoneInstance)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
             }
-            else if ((0, types_1.isClassInstance)(tupleEntry.type) && (0, typeUtils_1.isLiteralType)(tupleEntry.type)) {
+            else if ((0, types_2.isClassInstance)(tupleEntry.type) && (0, typeUtils_1.isLiteralType)(tupleEntry.type)) {
                 typesToEliminate.push(tupleEntry.type);
             }
         }
@@ -1143,15 +1166,15 @@ function narrowTypeForContainerType(evaluator, referenceType, containerType, isP
     }
     return (0, typeUtils_1.mapSubtypes)(referenceType, (referenceSubtype) => {
         referenceSubtype = evaluator.makeTopLevelTypeVarsConcrete(referenceSubtype);
-        if ((0, types_1.isClassInstance)(referenceSubtype) && referenceSubtype.literalValue === undefined) {
+        if ((0, types_2.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_1.combineTypes)(allLiteralTypes.filter((type) => !typesToEliminate.some((t) => (0, types_1.isTypeSame)(t, type))));
+                return (0, types_2.combineTypes)(allLiteralTypes.filter((type) => !typesToEliminate.some((t) => (0, types_2.isTypeSame)(t, type))));
             }
         }
-        if (typesToEliminate.some((t) => (0, types_1.isTypeSame)(t, referenceSubtype))) {
+        if (typesToEliminate.some((t) => (0, types_2.isTypeSame)(t, referenceSubtype))) {
             return undefined;
         }
         return referenceSubtype;
@@ -1160,7 +1183,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_1.isClassInstance)(containerType) || !types_1.ClassType.isBuiltIn(containerType, supportedContainers)) {
+    if (!(0, types_2.isClassInstance)(containerType) || !types_2.ClassType.isBuiltIn(containerType, supportedContainers)) {
         return undefined;
     }
     if (!containerType.typeArguments || containerType.typeArguments.length < 1) {
@@ -1168,7 +1191,7 @@ function getElementTypeForContainerNarrowing(containerType) {
     }
     let elementType = containerType.typeArguments[0];
     if ((0, typeUtils_1.isTupleClass)(containerType) && containerType.tupleTypeArguments) {
-        elementType = (0, types_1.combineTypes)(containerType.tupleTypeArguments.map((t) => t.type));
+        elementType = (0, types_2.combineTypes)(containerType.tupleTypeArguments.map((t) => t.type));
     }
     return elementType;
 }
@@ -1182,12 +1205,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_1.isAnyOrUnknown)(concreteReferenceType)) {
+        if ((0, types_2.isAnyOrUnknown)(concreteReferenceType)) {
             canNarrow = false;
             return referenceSubtype;
         }
         // Handle "type" specially.
-        if ((0, types_1.isClassInstance)(concreteReferenceType) && types_1.ClassType.isBuiltIn(concreteReferenceType, 'type')) {
+        if ((0, types_2.isClassInstance)(concreteReferenceType) && types_2.ClassType.isBuiltIn(concreteReferenceType, 'type')) {
             canNarrow = false;
             return referenceSubtype;
         }
@@ -1196,7 +1219,7 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
         }
         if (evaluator.assignType(elementTypeWithoutLiteral, concreteReferenceType)) {
             return (0, typeUtils_1.mapSubtypes)(elementType, (elementSubtype) => {
-                if ((0, types_1.isClassInstance)(elementSubtype) && (0, types_1.isSameWithoutLiteralValue)(referenceSubtype, elementSubtype)) {
+                if ((0, types_2.isClassInstance)(elementSubtype) && (0, types_2.isSameWithoutLiteralValue)(referenceSubtype, elementSubtype)) {
                     return elementSubtype;
                 }
                 return undefined;
@@ -1211,7 +1234,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_1.isAnyOrUnknown)(concreteElementType)) {
+        if ((0, types_2.isAnyOrUnknown)(concreteElementType)) {
             canNarrow = false;
             return referenceType;
         }
@@ -1220,14 +1243,14 @@ function narrowTypeForContainerElementType(evaluator, referenceType, elementType
         }
         return undefined;
     });
-    return canNarrow ? (0, types_1.combineTypes)([narrowedSupertypes, narrowedSubtypes]) : referenceType;
+    return canNarrow ? (0, types_2.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_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isTypedDictClass(subtype)) {
             const entries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluator, subtype, /* allowNarrowed */ true);
             const tdEntry = entries.get(literalKey.literalValue);
             if (isPositiveTest) {
@@ -1236,7 +1259,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_1.ClassType.isFinal(subtype) ? undefined : subtype;
+                    return types_2.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.
@@ -1258,7 +1281,7 @@ function narrowTypeForTypedDictKey(evaluator, referenceType, literalKey, isPosit
                     isProvided: true,
                 });
                 // Clone the TypedDict object with the new entries.
-                return types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForNarrowedTypedDictEntries(types_1.ClassType.cloneAsInstantiable(subtype), newNarrowedEntriesMap));
+                return types_2.ClassType.cloneAsInstance(types_2.ClassType.cloneForNarrowedTypedDictEntries(types_2.ClassType.cloneAsInstantiable(subtype), newNarrowedEntriesMap));
             }
             else {
                 return tdEntry !== undefined && (tdEntry.isRequired || tdEntry.isProvided) ? undefined : subtype;
@@ -1274,7 +1297,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_1.isClassInstance)(subtype) && types_1.ClassType.isTypedDictClass(subtype)) {
+        if ((0, types_2.isClassInstance)(subtype) && types_2.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)) {
@@ -1295,8 +1318,8 @@ function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, ind
     let canNarrow = true;
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         var _a;
-        if ((0, types_1.isClassInstance)(subtype) &&
-            types_1.ClassType.isTupleClass(subtype) &&
+        if ((0, types_2.isClassInstance)(subtype) &&
+            types_2.ClassType.isTupleClass(subtype) &&
             !(0, typeUtils_1.isUnboundedTupleClass)(subtype) &&
             typeof indexLiteralType.literalValue === 'number') {
             const indexValue = indexLiteralType.literalValue;
@@ -1323,22 +1346,22 @@ function narrowTypeForDiscriminatedTupleComparison(evaluator, referenceType, ind
 function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceType, memberName, literalType, isPositiveTest) {
     const narrowedType = (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         let memberInfo;
-        if ((0, types_1.isClassInstance)(subtype)) {
+        if ((0, types_2.isClassInstance)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
         }
-        else if ((0, types_1.isInstantiableClass)(subtype)) {
+        else if ((0, types_2.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_1.isClassInstance)(subtype) && (0, typeUtils_1.isProperty)(memberType)) {
+            if ((0, types_2.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_1.isFunction)(getterType) && getterType.details.declaredReturnType) {
-                        const getterReturnType = types_1.FunctionType.getSpecializedReturnType(getterType);
+                    if ((0, types_2.isFunction)(getterType) && getterType.details.declaredReturnType) {
+                        const getterReturnType = types_2.FunctionType.getSpecializedReturnType(getterType);
                         if (getterReturnType) {
                             memberType = getterReturnType;
                         }
@@ -1364,10 +1387,10 @@ function narrowTypeForDiscriminatedLiteralFieldComparison(evaluator, referenceTy
 function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType, memberName, isPositiveTest) {
     return (0, typeUtils_1.mapSubtypes)(referenceType, (subtype) => {
         let memberInfo;
-        if ((0, types_1.isClassInstance)(subtype)) {
+        if ((0, types_2.isClassInstance)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpObjectMember)(subtype, memberName);
         }
-        else if ((0, types_1.isInstantiableClass)(subtype)) {
+        else if ((0, types_2.isInstantiableClass)(subtype)) {
             memberInfo = (0, typeUtils_1.lookUpClassMember)(subtype, memberName);
         }
         if (memberInfo && memberInfo.isTypeDeclared) {
@@ -1380,13 +1403,13 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
                     if ((0, typeUtils_1.isProperty)(memberSubtype) || (0, typeUtils_1.isMaybeDescriptorInstance)(memberSubtype)) {
                         canNarrow = false;
                     }
-                    if ((0, types_1.isAnyOrUnknown)(memberSubtype) || (0, types_1.isNoneInstance)(memberSubtype) || (0, types_1.isNever)(memberSubtype)) {
+                    if ((0, types_2.isAnyOrUnknown)(memberSubtype) || (0, types_2.isNoneInstance)(memberSubtype) || (0, types_2.isNever)(memberSubtype)) {
                         canNarrow = false;
                     }
                 });
             }
             else {
-                canNarrow = (0, types_1.isNoneInstance)(memberType);
+                canNarrow = (0, types_2.isNoneInstance)(memberType);
             }
             if (canNarrow) {
                 return undefined;
@@ -1399,21 +1422,21 @@ function narrowTypeForDiscriminatedFieldNoneComparison(evaluator, referenceType,
 function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
     return evaluator.mapSubtypesExpandTypeVars(type, 
     /* conditionFilter */ undefined, (subtype, unexpandedSubtype) => {
-        if ((0, types_1.isClassInstance)(subtype)) {
-            const matches = types_1.ClassType.isDerivedFrom(classType, types_1.ClassType.cloneAsInstantiable(subtype));
+        if ((0, types_2.isClassInstance)(subtype)) {
+            const matches = types_2.ClassType.isDerivedFrom(classType, types_2.ClassType.cloneAsInstantiable(subtype));
             if (isPositiveTest) {
                 if (matches) {
-                    if (types_1.ClassType.isSameGenericClass(subtype, classType)) {
+                    if (types_2.ClassType.isSameGenericClass(subtype, classType)) {
                         return subtype;
                     }
-                    return (0, typeUtils_1.addConditionToType)(types_1.ClassType.cloneAsInstance(classType), subtype.condition);
+                    return (0, typeUtils_1.addConditionToType)(types_2.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_1.ClassType.isFinal(subtype)) {
+                if (matches && types_2.ClassType.isFinal(subtype)) {
                     return undefined;
                 }
                 // We can't eliminate the subtype in the negative
@@ -1422,11 +1445,11 @@ function narrowTypeForTypeIs(evaluator, type, classType, isPositiveTest) {
                 return subtype;
             }
         }
-        else if ((0, types_1.isNoneInstance)(subtype)) {
+        else if ((0, types_2.isNoneInstance)(subtype)) {
             return isPositiveTest ? undefined : subtype;
         }
-        else if ((0, types_1.isAnyOrUnknown)(subtype)) {
-            return isPositiveTest ? types_1.ClassType.cloneAsInstance(classType) : subtype;
+        else if ((0, types_2.isAnyOrUnknown)(subtype)) {
+            return isPositiveTest ? types_2.ClassType.cloneAsInstance(classType) : subtype;
         }
         return unexpandedSubtype;
     });
@@ -1437,9 +1460,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_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(literalType, subtype)) {
+        if ((0, types_2.isClassInstance)(subtype) && types_2.ClassType.isSameGenericClass(literalType, subtype)) {
             if (subtype.literalValue !== undefined) {
-                const literalValueMatches = types_1.ClassType.isLiteralValueSame(subtype, literalType);
+                const literalValueMatches = types_2.ClassType.isLiteralValueSame(subtype, literalType);
                 if ((literalValueMatches && !isPositiveTest) || (!literalValueMatches && isPositiveTest)) {
                     return undefined;
                 }
@@ -1453,12 +1476,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_1.combineTypes)(allLiteralTypes.filter((type) => !types_1.ClassType.isLiteralValueSame(type, literalType)));
+                    return (0, types_2.combineTypes)(allLiteralTypes.filter((type) => !types_2.ClassType.isLiteralValueSame(type, literalType)));
                 }
             }
         }
         else if (isPositiveTest) {
-            if (isIsOperator || (0, types_1.isNoneInstance)(subtype)) {
+            if (isIsOperator || (0, types_2.isNoneInstance)(subtype)) {
                 return undefined;
             }
         }
@@ -1466,22 +1489,22 @@ function narrowTypeForLiteralComparison(evaluator, referenceType, literalType, i
     });
 }
 function enumerateLiteralsForType(evaluator, type) {
-    if (types_1.ClassType.isBuiltIn(type, 'bool')) {
+    if (types_2.ClassType.isBuiltIn(type, 'bool')) {
         // Booleans have only two types: True and False.
         return [
-            types_1.ClassType.cloneWithLiteral(type, /* value */ true),
-            types_1.ClassType.cloneWithLiteral(type, /* value */ false),
+            types_2.ClassType.cloneWithLiteral(type, /* value */ true),
+            types_2.ClassType.cloneWithLiteral(type, /* value */ false),
         ];
     }
-    if (types_1.ClassType.isEnumClass(type)) {
+    if (types_2.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_1.isClassInstance)(symbolType) &&
-                    types_1.ClassType.isSameGenericClass(type, symbolType) &&
+                if ((0, types_2.isClassInstance)(symbolType) &&
+                    types_2.ClassType.isSameGenericClass(type, symbolType) &&
                     symbolType.literalValue !== undefined) {
                     enumList.push(symbolType);
                 }
@@ -1508,7 +1531,7 @@ function narrowTypeForCallable(evaluator, type, isPositiveTest, errorNode, allow
                 return isPositiveTest ? undefined : subtype;
             }
             case 7 /* Class */: {
-                if (types_1.TypeBase.isInstantiable(subtype)) {
+                if (types_2.TypeBase.isInstantiable(subtype)) {
                     return isPositiveTest ? subtype : undefined;
                 }
                 // See if the object is callable.
@@ -1523,24 +1546,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_1.ClassType.createInstantiable(className, ParseTreeUtils.getClassFullName(errorNode, fileInfo.moduleName, className), fileInfo.moduleName, fileInfo.filePath, 0 /* None */, ParseTreeUtils.getTypeSourceId(errorNode), 
+                        let newClassType = types_2.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_1.ClassType.cloneAsInstantiable(subtype)];
+                        newClassType.details.baseClasses = [types_2.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_1.FunctionType.createSynthesizedInstance('__call__');
+                        const callMethod = types_2.FunctionType.createSynthesizedInstance('__call__');
                         const selfParam = {
                             category: 0 /* Simple */,
                             name: 'self',
-                            type: types_1.ClassType.cloneAsInstance(newClassType),
+                            type: types_2.ClassType.cloneAsInstance(newClassType),
                             hasDeclaredType: true,
                         };
-                        types_1.FunctionType.addParameter(callMethod, selfParam);
-                        types_1.FunctionType.addDefaultParameters(callMethod);
-                        callMethod.details.declaredReturnType = types_1.UnknownType.create();
+                        types_2.FunctionType.addParameter(callMethod, selfParam);
+                        types_2.FunctionType.addDefaultParameters(callMethod);
+                        callMethod.details.declaredReturnType = types_2.UnknownType.create();
                         newClassType.details.fields.set('__call__', symbol_1.Symbol.createWithType(4 /* ClassMember */, callMethod));
-                        return types_1.ClassType.cloneAsInstance(newClassType);
+                        return types_2.ClassType.cloneAsInstance(newClassType);
                     }
                     return undefined;
                 }