@zzzen/pyright-internal 1.2.0-dev.20240707 → 1.2.0-dev.20240721

package/dist/analyzer/typeUtils.js

@@ -8,9 +8,9 @@
  * Functions that operate on Type objects.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isTupleClass = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.selfSpecializeClass = exports.getUnknownTypeForCallable = exports.getUnknownTypeForVariadicTypeVar = exports.getUnknownTypeForParamSpec = exports.getUnknownTypeForTypeVar = exports.specializeWithUnknownTypeArgs = exports.specializeWithDefaultTypeArgs = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSignature = exports.allSubtypes = exports.someSubtypes = exports.doForEachSubtype = exports.sortTypes = exports.cleanIncompleteUnknown = exports.mapSignatures = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.removeNoneFromUnion = exports.isNoneTypeClass = exports.isNoneInstance = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
-exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.replaceTypeVarsWithAny = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = void 0;
-exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.getDeclaringModulesForType = exports.computeMroLinearization = void 0;
+exports.isTupleGradualForm = exports.isMaybeDescriptorInstance = exports.isDescriptorInstance = exports.isCallableType = exports.isProperty = exports.isEllipsisType = exports.getUnionSubtypeCount = exports.getLiteralTypeClassName = exports.containsLiteralType = exports.isLiteralTypeOrUnion = exports.isLiteralType = exports.getSpecializedTupleType = exports.selfSpecializeClass = exports.getUnknownTypeForCallable = exports.getUnknownTypeForVariadicTypeVar = exports.getUnknownTypeForParamSpec = exports.getUnknownTypeForTypeVar = exports.specializeWithUnknownTypeArgs = exports.specializeWithDefaultTypeArgs = exports.getTypeVarScopeIds = exports.getTypeVarScopeId = exports.transformPossibleRecursiveTypeAlias = exports.isTypeAliasRecursive = exports.isTypeAliasPlaceholder = exports.getTypeCondition = exports.addConditionToType = exports.getFullNameOfType = exports.derivesFromAnyOrUnknown = exports.isUnionableType = exports.preserveUnknown = exports.areTypesSame = exports.doForEachSignature = exports.allSubtypes = exports.someSubtypes = exports.doForEachSubtype = exports.sortTypes = exports.cleanIncompleteUnknown = exports.mapSignatures = exports.mapSubtypes = exports.makeInferenceContext = exports.isTypeVarSame = exports.isIncompleteUnknown = exports.removeNoneFromUnion = exports.isNoneTypeClass = exports.isNoneInstance = exports.isOptionalType = exports.UniqueSignatureTracker = exports.AssignTypeFlags = exports.ClassIteratorFlags = exports.MemberAccessFlags = void 0;
+exports.requiresTypeArguments = exports.getGeneratorTypeArgs = exports.specializeTupleClass = exports.combineSameSizedTuples = exports.explodeGenericClass = exports.isPartlyUnknown = exports.containsAnyOrUnknown = exports.containsAnyRecursive = exports.getMembersForModule = exports.getMembersForClass = exports.convertToInstantiable = exports.convertToInstance = exports.isEffectivelyInstantiable = exports.isMetaclassInstance = exports.isInstantiableMetaclass = exports.getGeneratorYieldType = exports.getDeclaredGeneratorReturnType = exports.synthesizeTypeVarForSelfCls = exports.derivesFromClassRecursive = exports.derivesFromStdlibClass = exports.specializeForBaseClass = exports.buildTypeVarContext = exports.buildTypeVarContextFromSpecializedClass = exports.setTypeArgumentsRecursive = exports.specializeClassType = exports.getTypeVarArgumentsRecursive = exports.addTypeVarsToListIfUnique = exports.getClassFieldsRecursive = exports.getClassIterator = exports.getClassMemberIterator = exports.lookUpClassMember = exports.lookUpObjectMember = exports.getContainerDepth = exports.getProtocolSymbolsRecursive = exports.getProtocolSymbols = exports.transformExpectedType = exports.replaceTypeVarsWithAny = exports.validateTypeVarDefault = exports.applyInScopePlaceholders = exports.applySourceContextTypeVarsToSignature = exports.applySourceContextTypeVars = exports.applySolvedTypeVars = exports.updateTypeWithExternalTypeVars = exports.updateTypeWithInternalTypeVars = exports.ensureFunctionSignaturesAreUnique = exports.populateTypeVarContextForSelfType = exports.partiallySpecializeType = exports.isTupleIndexUnambiguous = exports.isUnboundedTupleClass = exports.isTupleClass = void 0;
+exports.convertParamSpecValueToType = exports.convertTypeToParamSpecValue = exports.convertArgumentNodeToFunctionArgument = exports.getDeclaringModulesForType = exports.computeMroLinearization = exports.isVarianceOfTypeArgumentCompatible = exports.combineVariances = exports.requiresSpecialization = void 0;
 const collectionUtils_1 = require("../common/collectionUtils");
 const debug_1 = require("../common/debug");
 const symbol_1 = require("./symbol");
@@ -96,13 +96,13 @@ var AssignTypeFlags;
     // as incompatible. Also, treat all source TypeVars as their
     // concrete counterparts. This option is used for validating
     // whether overload signatures overlap.
-    AssignTypeFlags[AssignTypeFlags["OverloadOverlapCheck"] = 16] = "OverloadOverlapCheck";
+    AssignTypeFlags[AssignTypeFlags["OverloadOverlap"] = 16] = "OverloadOverlap";
     // When used in conjunction with OverloadOverlapCheck, look
     // for partial overlaps. For example, `int | list` overlaps
     // partially with `int | str`.
-    AssignTypeFlags[AssignTypeFlags["PartialOverloadOverlapCheck"] = 32] = "PartialOverloadOverlapCheck";
+    AssignTypeFlags[AssignTypeFlags["PartialOverloadOverlap"] = 32] = "PartialOverloadOverlap";
     // For function types, skip the return type check.
-    AssignTypeFlags[AssignTypeFlags["SkipFunctionReturnTypeCheck"] = 64] = "SkipFunctionReturnTypeCheck";
+    AssignTypeFlags[AssignTypeFlags["SkipReturnTypeCheck"] = 64] = "SkipReturnTypeCheck";
     // Allow bool values to be assigned to TypeGuard[x] types.
     AssignTypeFlags[AssignTypeFlags["AllowBoolTypeGuard"] = 128] = "AllowBoolTypeGuard";
     // In most cases, literals are stripped when assigning to a
@@ -129,17 +129,13 @@ var AssignTypeFlags;
     // default type arguments (typically "Unknown"). This flag skips
     // this step.
     AssignTypeFlags[AssignTypeFlags["AllowUnspecifiedTypeArguments"] = 8192] = "AllowUnspecifiedTypeArguments";
-    // PEP 544 says that if the dest type is a type[Proto] class,
-    // the source must be a "concrete" (non-protocol) class. This
-    // flag skips this check.
-    AssignTypeFlags[AssignTypeFlags["IgnoreProtocolAssignmentCheck"] = 16384] = "IgnoreProtocolAssignmentCheck";
     // Normally all special form classes are incompatible with type[T],
     // but a few of them are allowed in the context of an isinstance
     // or issubclass call.
-    AssignTypeFlags[AssignTypeFlags["AllowIsinstanceSpecialForms"] = 32768] = "AllowIsinstanceSpecialForms";
+    AssignTypeFlags[AssignTypeFlags["AllowIsinstanceSpecialForms"] = 16384] = "AllowIsinstanceSpecialForms";
     // When comparing two methods, skip the type check for the "self" or "cls"
     // parameters. This is used for variance inference and validation.
-    AssignTypeFlags[AssignTypeFlags["IgnoreSelfClsParamCompatibility"] = 65536] = "IgnoreSelfClsParamCompatibility";
+    AssignTypeFlags[AssignTypeFlags["SkipSelfClsParamCheck"] = 32768] = "SkipSelfClsParamCheck";
 })(AssignTypeFlags || (exports.AssignTypeFlags = AssignTypeFlags = {}));
 // Tracks whether a function signature has been seen before within
 // an expression. For example, in the expression "foo(foo, foo)", the
@@ -164,8 +160,8 @@ class UniqueSignatureTracker {
     findSignature(signature) {
         // Use the associated overload type if this is a function associated with an overload.
         let effectiveSignature = signature;
-        if ((0, types_1.isFunction)(signature) && signature.overloaded) {
-            effectiveSignature = signature.overloaded;
+        if ((0, types_1.isFunction)(signature) && signature.priv.overloaded) {
+            effectiveSignature = signature.priv.overloaded;
         }
         return this._trackedSignatures.find((s) => {
             return (0, types_1.isTypeSame)(effectiveSignature, s.type);
@@ -174,7 +170,7 @@ class UniqueSignatureTracker {
     addSignature(signature, offset) {
         var _a;
         // If this function is part of a broader overload, use the overload instead.
-        const effectiveSignature = (0, types_1.isFunction)(signature) ? (_a = signature.overloaded) !== null && _a !== void 0 ? _a : signature : signature;
+        const effectiveSignature = (0, types_1.isFunction)(signature) ? (_a = signature.priv.overloaded) !== null && _a !== void 0 ? _a : signature : signature;
         const existingSignature = this.findSignature(effectiveSignature);
         if (existingSignature) {
             if (!existingSignature.expressionOffsets.some((o) => o === offset)) {
@@ -209,7 +205,7 @@ function removeNoneFromUnion(type) {
 }
 exports.removeNoneFromUnion = removeNoneFromUnion;
 function isIncompleteUnknown(type) {
-    return (0, types_1.isUnknown)(type) && type.isIncomplete;
+    return (0, types_1.isUnknown)(type) && type.priv.isIncomplete;
 }
 exports.isIncompleteUnknown = isIncompleteUnknown;
 // Similar to isTypeSame except that type1 is a TypeVar and type2
@@ -220,7 +216,7 @@ function isTypeVarSame(type1, type2) {
         return true;
     }
     // If this isn't a bound TypeVar, return false.
-    if (type1.details.isParamSpec || type1.details.isVariadic || !type1.details.boundType) {
+    if (type1.shared.isParamSpec || type1.shared.isVariadic || !type1.shared.boundType) {
         return false;
     }
     // If the second type isn't a union, return false.
@@ -235,7 +231,7 @@ function isTypeVarSame(type1, type2) {
         if (!(0, types_1.isTypeSame)(type1, subtype)) {
             const conditions = getTypeCondition(subtype);
             if (!conditions ||
-                !conditions.some((condition) => condition.typeVar.nameWithScope === type1.nameWithScope)) {
+                !conditions.some((condition) => condition.typeVar.priv.nameWithScope === type1.priv.nameWithScope)) {
                 isCompatible = false;
             }
         }
@@ -243,19 +239,20 @@ function isTypeVarSame(type1, type2) {
     return isCompatible;
 }
 exports.isTypeVarSame = isTypeVarSame;
-function makeInferenceContext(expectedType, isTypeIncomplete) {
+function makeInferenceContext(expectedType, isTypeIncomplete, returnTypeOverride) {
     if (!expectedType) {
         return undefined;
     }
-    return { expectedType, isTypeIncomplete };
+    return { expectedType, isTypeIncomplete, returnTypeOverride };
 }
 exports.makeInferenceContext = makeInferenceContext;
 // Calls a callback for each subtype and combines the results
 // into a final type. It performs no memory allocations if the
 // transformed type is the same as the original.
-function mapSubtypes(type, callback, sortSubtypes = false) {
+function mapSubtypes(type, callback, options) {
+    var _a;
     if ((0, types_1.isUnion)(type)) {
-        const subtypes = sortSubtypes ? sortTypes(type.subtypes) : type.subtypes;
+        const subtypes = (options === null || options === void 0 ? void 0 : options.sortSubtypes) ? sortTypes(type.priv.subtypes) : type.priv.subtypes;
         for (let i = 0; i < subtypes.length; i++) {
             const subtype = subtypes[i];
             const transformedType = callback(subtype);
@@ -272,10 +269,19 @@ function mapSubtypes(type, callback, sortSubtypes = false) {
                 for (i++; i < subtypes.length; i++) {
                     accumulateSubtype(callback(subtypes[i]));
                 }
-                const newType = (0, types_1.combineTypes)(typesToCombine);
-                // Do our best to retain type aliases.
-                if (newType.category === 8 /* TypeCategory.Union */) {
-                    types_1.UnionType.addTypeAliasSource(newType, type);
+                const newType = (0, types_1.combineTypes)(typesToCombine, {
+                    skipElideRedundantLiterals: options === null || options === void 0 ? void 0 : options.skipElideRedundantLiterals,
+                });
+                if (options === null || options === void 0 ? void 0 : options.retainTypeAlias) {
+                    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+                        types_1.TypeBase.setTypeAliasInfo(newType, type.props.typeAliasInfo);
+                    }
+                }
+                else {
+                    // Do our best to retain type aliases.
+                    if (newType.category === 8 /* TypeCategory.Union */) {
+                        types_1.UnionType.addTypeAliasSource(newType, type);
+                    }
                 }
                 return newType;
             }
@@ -293,12 +299,12 @@ exports.mapSubtypes = mapSubtypes;
 // caller to replace one or more signatures with new ones.
 function mapSignatures(type, callback) {
     if ((0, types_1.isFunction)(type)) {
-        return callback(type, 0);
+        return callback(type);
     }
     const newSignatures = [];
     let changeMade = false;
     types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
-        const newOverload = callback(overload, index);
+        const newOverload = callback(overload);
         if (newOverload !== overload) {
             changeMade = true;
         }
@@ -312,7 +318,11 @@ function mapSignatures(type, callback) {
     // Add the unmodified implementation if it's present.
     const implementation = types_1.OverloadedFunctionType.getImplementation(type);
     if (implementation) {
-        newSignatures.push(implementation);
+        const newImplementation = callback(implementation);
+        if (newImplementation) {
+            changeMade = true;
+            newSignatures.push(newImplementation);
+        }
     }
     if (!changeMade) {
         return type;
@@ -336,13 +346,13 @@ function cleanIncompleteUnknown(type, recursionCount = 0) {
     recursionCount++;
     const result = mapSubtypes(type, (subtype) => {
         // If it's an incomplete unknown, eliminate it.
-        if ((0, types_1.isUnknown)(subtype) && subtype.isIncomplete) {
+        if ((0, types_1.isUnknown)(subtype) && subtype.priv.isIncomplete) {
             return undefined;
         }
-        if ((0, types_1.isClass)(subtype) && subtype.typeArguments) {
+        if ((0, types_1.isClass)(subtype) && subtype.priv.typeArguments) {
             let typeChanged = false;
-            if (subtype.tupleTypeArguments) {
-                const updatedTupleTypeArgs = subtype.tupleTypeArguments.map((tupleTypeArg) => {
+            if (subtype.priv.tupleTypeArguments) {
+                const updatedTupleTypeArgs = subtype.priv.tupleTypeArguments.map((tupleTypeArg) => {
                     const newTypeArg = cleanIncompleteUnknown(tupleTypeArg.type, recursionCount);
                     if (newTypeArg !== tupleTypeArg.type) {
                         typeChanged = true;
@@ -354,11 +364,11 @@ function cleanIncompleteUnknown(type, recursionCount = 0) {
                     };
                 });
                 if (typeChanged) {
-                    return specializeTupleClass(subtype, updatedTupleTypeArgs, !!subtype.isTypeArgumentExplicit, !!subtype.isUnpacked);
+                    return specializeTupleClass(subtype, updatedTupleTypeArgs, !!subtype.priv.isTypeArgumentExplicit, !!subtype.priv.isUnpacked);
                 }
             }
             else {
-                const updatedTypeArgs = subtype.typeArguments.map((typeArg) => {
+                const updatedTypeArgs = subtype.priv.typeArguments.map((typeArg) => {
                     const newTypeArg = cleanIncompleteUnknown(typeArg, recursionCount);
                     if (newTypeArg !== typeArg) {
                         typeChanged = true;
@@ -366,7 +376,7 @@ function cleanIncompleteUnknown(type, recursionCount = 0) {
                     return newTypeArg;
                 });
                 if (typeChanged) {
-                    return types_1.ClassType.cloneForSpecialization(subtype, updatedTypeArgs, !!subtype.isTypeArgumentExplicit);
+                    return types_1.ClassType.cloneForSpecialization(subtype, updatedTypeArgs, !!subtype.priv.isTypeArgumentExplicit);
                 }
             }
         }
@@ -403,14 +413,14 @@ function compareTypes(a, b, recursionCount = 0) {
         }
         case 4 /* TypeCategory.Function */: {
             const bFunc = b;
-            const aParamCount = a.details.parameters.length;
-            const bParamCount = bFunc.details.parameters.length;
+            const aParamCount = a.shared.parameters.length;
+            const bParamCount = bFunc.shared.parameters.length;
             if (aParamCount !== bParamCount) {
                 return bParamCount - aParamCount;
             }
             for (let i = 0; i < aParamCount; i++) {
-                const aParam = a.details.parameters[i];
-                const bParam = bFunc.details.parameters[i];
+                const aParam = a.shared.parameters[i];
+                const bParam = bFunc.shared.parameters[i];
                 if (aParam.category !== bParam.category) {
                     return bParam.category - aParam.category;
                 }
@@ -423,8 +433,8 @@ function compareTypes(a, b, recursionCount = 0) {
             if (returnTypeComparison !== 0) {
                 return returnTypeComparison;
             }
-            const aName = a.details.name;
-            const bName = bFunc.details.name;
+            const aName = a.shared.name;
+            const bName = bFunc.shared.name;
             if (aName < bName) {
                 return -1;
             }
@@ -435,13 +445,13 @@ function compareTypes(a, b, recursionCount = 0) {
         }
         case 5 /* TypeCategory.OverloadedFunction */: {
             const bOver = b;
-            const aOverloadCount = a.overloads.length;
-            const bOverloadCount = bOver.overloads.length;
+            const aOverloadCount = a.priv.overloads.length;
+            const bOverloadCount = bOver.priv.overloads.length;
             if (aOverloadCount !== bOverloadCount) {
                 return bOverloadCount - aOverloadCount;
             }
             for (let i = 0; i < aOverloadCount; i++) {
-                const typeComparison = compareTypes(a.overloads[i], bOver.overloads[i]);
+                const typeComparison = compareTypes(a.priv.overloads[i], bOver.priv.overloads[i]);
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -474,17 +484,17 @@ function compareTypes(a, b, recursionCount = 0) {
                 return -1;
             }
             // Sort non-generics before generics.
-            if (a.details.typeParameters.length > 0 || isTupleClass(a)) {
-                if (bClass.details.typeParameters.length === 0) {
+            if (a.shared.typeParameters.length > 0 || isTupleClass(a)) {
+                if (bClass.shared.typeParameters.length === 0) {
                     return 1;
                 }
             }
-            else if (bClass.details.typeParameters.length > 0 || isTupleClass(bClass)) {
+            else if (bClass.shared.typeParameters.length > 0 || isTupleClass(bClass)) {
                 return -1;
             }
             // Sort by class name.
-            const aName = a.details.name;
-            const bName = b.details.name;
+            const aName = a.shared.name;
+            const bName = b.shared.name;
             if (aName < bName) {
                 return -1;
             }
@@ -492,8 +502,8 @@ function compareTypes(a, b, recursionCount = 0) {
                 return 1;
             }
             // Sort by type argument count.
-            const aTypeArgCount = a.typeArguments ? a.typeArguments.length : 0;
-            const bTypeArgCount = bClass.typeArguments ? bClass.typeArguments.length : 0;
+            const aTypeArgCount = a.priv.typeArguments ? a.priv.typeArguments.length : 0;
+            const bTypeArgCount = bClass.priv.typeArguments ? bClass.priv.typeArguments.length : 0;
             if (aTypeArgCount < bTypeArgCount) {
                 return -1;
             }
@@ -502,7 +512,7 @@ function compareTypes(a, b, recursionCount = 0) {
             }
             // Sort by type argument.
             for (let i = 0; i < aTypeArgCount; i++) {
-                const typeComparison = compareTypes(a.typeArguments[i], bClass.typeArguments[i], recursionCount);
+                const typeComparison = compareTypes(a.priv.typeArguments[i], bClass.priv.typeArguments[i], recursionCount);
                 if (typeComparison !== 0) {
                     return typeComparison;
                 }
@@ -510,13 +520,13 @@ function compareTypes(a, b, recursionCount = 0) {
             return 0;
         }
         case 7 /* TypeCategory.Module */: {
-            const aName = a.moduleName;
-            const bName = b.moduleName;
+            const aName = a.priv.moduleName;
+            const bName = b.priv.moduleName;
             return aName < bName ? -1 : aName === bName ? 0 : 1;
         }
         case 9 /* TypeCategory.TypeVar */: {
-            const aName = a.details.name;
-            const bName = b.details.name;
+            const aName = a.shared.name;
+            const bName = b.shared.name;
             return aName < bName ? -1 : aName === bName ? 0 : 1;
         }
     }
@@ -524,7 +534,7 @@ function compareTypes(a, b, recursionCount = 0) {
 }
 function doForEachSubtype(type, callback, sortSubtypes = false) {
     if ((0, types_1.isUnion)(type)) {
-        const subtypes = sortSubtypes ? sortTypes(type.subtypes) : type.subtypes;
+        const subtypes = sortSubtypes ? sortTypes(type.priv.subtypes) : type.priv.subtypes;
         subtypes.forEach((subtype, index) => {
             callback(subtype, index, subtypes);
         });
@@ -536,7 +546,7 @@ function doForEachSubtype(type, callback, sortSubtypes = false) {
 exports.doForEachSubtype = doForEachSubtype;
 function someSubtypes(type, callback) {
     if ((0, types_1.isUnion)(type)) {
-        return type.subtypes.some((subtype) => {
+        return type.priv.subtypes.some((subtype) => {
             return callback(subtype);
         });
     }
@@ -547,7 +557,7 @@ function someSubtypes(type, callback) {
 exports.someSubtypes = someSubtypes;
 function allSubtypes(type, callback) {
     if ((0, types_1.isUnion)(type)) {
-        return type.subtypes.every((subtype) => {
+        return type.priv.subtypes.every((subtype) => {
             callback(subtype);
         });
     }
@@ -584,10 +594,10 @@ exports.areTypesSame = areTypesSame;
 // the incomplete flag on the unknown if present. The caller should verify that
 // one or the other type is Unknown or Any.
 function preserveUnknown(type1, type2) {
-    if ((0, types_1.isUnknown)(type1) && type1.isIncomplete) {
+    if ((0, types_1.isUnknown)(type1) && type1.priv.isIncomplete) {
         return type1;
     }
-    else if ((0, types_1.isUnknown)(type2) && type2.isIncomplete) {
+    else if ((0, types_1.isUnknown)(type2) && type2.priv.isIncomplete) {
         return type2;
     }
     else if ((0, types_1.isUnknown)(type1) || (0, types_1.isUnknown)(type2)) {
@@ -633,32 +643,33 @@ function derivesFromAnyOrUnknown(type) {
 }
 exports.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
 function getFullNameOfType(type) {
-    var _a;
-    if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.fullName) {
-        return type.typeAliasInfo.fullName;
+    var _a, _b;
+    if ((_b = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.fullName) {
+        return type.props.typeAliasInfo.fullName;
     }
     switch (type.category) {
         case 2 /* TypeCategory.Any */:
         case 1 /* TypeCategory.Unknown */:
             return 'typing.Any';
         case 6 /* TypeCategory.Class */:
-            return type.details.fullName;
+            return type.shared.fullName;
         case 4 /* TypeCategory.Function */:
-            return type.details.fullName;
+            return type.shared.fullName;
         case 7 /* TypeCategory.Module */:
-            return type.moduleName;
+            return type.priv.moduleName;
         case 5 /* TypeCategory.OverloadedFunction */:
-            return type.overloads[0].details.fullName;
+            return type.priv.overloads[0].shared.fullName;
     }
     return undefined;
 }
 exports.getFullNameOfType = getFullNameOfType;
 function addConditionToType(type, condition, skipSelfCondition = false) {
+    var _a, _b;
     if (!condition) {
         return type;
     }
     if (skipSelfCondition) {
-        condition = condition.filter((c) => !c.typeVar.details.isSynthesizedSelf);
+        condition = condition.filter((c) => !c.typeVar.shared.isSynthesizedSelf);
         if (condition.length === 0) {
             return type;
         }
@@ -672,17 +683,18 @@ function addConditionToType(type, condition, skipSelfCondition = false) {
         case 9 /* TypeCategory.TypeVar */:
             return type;
         case 4 /* TypeCategory.Function */:
-            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
+            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition, condition));
         case 5 /* TypeCategory.OverloadedFunction */:
-            return types_1.OverloadedFunctionType.create(type.overloads.map((t) => addConditionToType(t, condition)));
+            return types_1.OverloadedFunctionType.create(type.priv.overloads.map((t) => addConditionToType(t, condition)));
         case 6 /* TypeCategory.Class */:
-            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine(type.condition, condition));
+            return types_1.TypeBase.cloneForCondition(type, types_1.TypeCondition.combine((_b = type.props) === null || _b === void 0 ? void 0 : _b.condition, condition));
         case 8 /* TypeCategory.Union */:
-            return (0, types_1.combineTypes)(type.subtypes.map((t) => addConditionToType(t, condition)));
+            return (0, types_1.combineTypes)(type.priv.subtypes.map((t) => addConditionToType(t, condition)));
     }
 }
 exports.addConditionToType = addConditionToType;
 function getTypeCondition(type) {
+    var _a;
     switch (type.category) {
         case 0 /* TypeCategory.Unbound */:
         case 1 /* TypeCategory.Unknown */:
@@ -695,7 +707,7 @@ function getTypeCondition(type) {
             return undefined;
         case 6 /* TypeCategory.Class */:
         case 4 /* TypeCategory.Function */:
-            return type.condition;
+            return (_a = type.props) === null || _a === void 0 ? void 0 : _a.condition;
     }
 }
 exports.getTypeCondition = getTypeCondition;
@@ -709,6 +721,7 @@ exports.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
 // within the specified type. It's OK if it's used indirectly as
 // a type argument.
 function isTypeAliasRecursive(typeAliasPlaceholder, type) {
+    var _a, _b;
     if (type.category !== 8 /* TypeCategory.Union */) {
         if (type === typeAliasPlaceholder) {
             return true;
@@ -716,31 +729,32 @@ function isTypeAliasRecursive(typeAliasPlaceholder, type) {
         // Handle the specific case where the type alias directly refers to itself.
         // In this case, the type will be unbound because it could not be resolved.
         return ((0, types_1.isUnbound)(type) &&
-            type.typeAliasInfo &&
-            type.typeAliasInfo.name === typeAliasPlaceholder.details.recursiveTypeAliasName);
+            ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) &&
+            type.props.typeAliasInfo.name === ((_b = typeAliasPlaceholder.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.name));
     }
-    return ((0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeVar)(subtype) && subtype.details === typeAliasPlaceholder.details) !==
+    return ((0, types_1.findSubtype)(type, (subtype) => (0, types_1.isTypeVar)(subtype) && subtype.shared === typeAliasPlaceholder.shared) !==
         undefined);
 }
 exports.isTypeAliasRecursive = isTypeAliasRecursive;
 function transformPossibleRecursiveTypeAlias(type) {
-    var _a;
+    var _a, _b;
     if (type) {
-        if ((0, types_1.isTypeVar)(type) && type.details.recursiveTypeAliasName && type.details.boundType) {
+        const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+        if ((0, types_1.isTypeVar)(type) && ((_b = type.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.name) && type.shared.boundType) {
             const unspecializedType = types_1.TypeBase.isInstance(type)
-                ? convertToInstance(type.details.boundType)
-                : type.details.boundType;
-            if (!((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) || !type.details.recursiveTypeParameters) {
+                ? convertToInstance(type.shared.boundType)
+                : type.shared.boundType;
+            if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) || !type.shared.recursiveAlias.typeParameters) {
                 return unspecializedType;
             }
-            const typeVarContext = buildTypeVarContext(type.details.recursiveTypeParameters, type.typeAliasInfo.typeArguments, getTypeVarScopeId(type));
+            const typeVarContext = buildTypeVarContext(type.shared.recursiveAlias.typeParameters, aliasInfo.typeArguments, getTypeVarScopeId(type));
             return applySolvedTypeVars(unspecializedType, typeVarContext);
         }
-        if ((0, types_1.isUnion)(type) && type.includesRecursiveTypeAlias) {
+        if ((0, types_1.isUnion)(type) && type.priv.includesRecursiveTypeAlias) {
             let newType = mapSubtypes(type, (subtype) => transformPossibleRecursiveTypeAlias(subtype));
-            if (newType !== type && type.typeAliasInfo) {
+            if (newType !== type && aliasInfo) {
                 // Copy the type alias information if present.
-                newType = types_1.TypeBase.cloneForTypeAlias(newType, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.moduleName, type.typeAliasInfo.fileUri, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
+                newType = types_1.TypeBase.cloneForTypeAlias(newType, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParameters, aliasInfo.typeArguments);
             }
             return newType;
         }
@@ -750,13 +764,13 @@ function transformPossibleRecursiveTypeAlias(type) {
 exports.transformPossibleRecursiveTypeAlias = transformPossibleRecursiveTypeAlias;
 function getTypeVarScopeId(type) {
     if ((0, types_1.isClass)(type)) {
-        return type.details.typeVarScopeId;
+        return type.shared.typeVarScopeId;
     }
     if ((0, types_1.isFunction)(type)) {
-        return type.details.typeVarScopeId;
+        return type.shared.typeVarScopeId;
     }
     if ((0, types_1.isTypeVar)(type)) {
-        return type.scopeId;
+        return type.priv.scopeId;
     }
     return undefined;
 }
@@ -770,14 +784,11 @@ function getTypeVarScopeIds(type) {
         scopeIds.push(scopeId);
     }
     if ((0, types_1.isFunction)(type)) {
-        if (type.details.constructorTypeVarScopeId) {
-            scopeIds.push(type.details.constructorTypeVarScopeId);
-        }
-        if (type.details.higherOrderTypeVarScopeIds) {
-            scopeIds.push(...type.details.higherOrderTypeVarScopeIds);
+        if (type.priv.constructorTypeVarScopeId) {
+            scopeIds.push(type.priv.constructorTypeVarScopeId);
         }
-        if (type.boundTypeVarScopeId) {
-            scopeIds.push(type.boundTypeVarScopeId);
+        if (type.priv.higherOrderTypeVarScopeIds) {
+            scopeIds.push(...type.priv.higherOrderTypeVarScopeIds);
         }
     }
     return scopeIds;
@@ -787,35 +798,35 @@ exports.getTypeVarScopeIds = getTypeVarScopeIds;
 // specified, specialize it with default type arguments (Unknown or the
 // default type if provided).
 function specializeWithDefaultTypeArgs(type) {
-    if (type.details.typeParameters.length === 0 || type.typeArguments) {
+    if (type.shared.typeParameters.length === 0 || type.priv.typeArguments) {
         return type;
     }
-    return types_1.ClassType.cloneForSpecialization(type, type.details.typeParameters.map((param) => param.details.defaultType), 
+    return types_1.ClassType.cloneForSpecialization(type, type.shared.typeParameters.map((param) => param.shared.defaultType), 
     /* isTypeArgumentExplicit */ false, 
-    /* includeSubclasses */ type.includeSubclasses);
+    /* includeSubclasses */ type.priv.includeSubclasses);
 }
 exports.specializeWithDefaultTypeArgs = specializeWithDefaultTypeArgs;
 // Specializes the class with "Unknown" type args (or the equivalent for ParamSpecs
 // or TypeVarTuples).
 function specializeWithUnknownTypeArgs(type, tupleClassType) {
-    if (type.details.typeParameters.length === 0) {
+    if (type.shared.typeParameters.length === 0) {
         return type;
     }
     if (isTupleClass(type)) {
         return types_1.ClassType.cloneIncludeSubclasses(specializeTupleClass(type, [{ type: types_1.UnknownType.create(), isUnbounded: true }], 
-        /* isTypeArgumentExplicit */ false), !!type.includeSubclasses);
+        /* isTypeArgumentExplicit */ false), !!type.priv.includeSubclasses);
     }
-    return types_1.ClassType.cloneForSpecialization(type, type.details.typeParameters.map((param) => getUnknownTypeForTypeVar(param, tupleClassType)), 
+    return types_1.ClassType.cloneForSpecialization(type, type.shared.typeParameters.map((param) => getUnknownTypeForTypeVar(param, tupleClassType)), 
     /* isTypeArgumentExplicit */ false, 
-    /* includeSubclasses */ type.includeSubclasses);
+    /* includeSubclasses */ type.priv.includeSubclasses);
 }
 exports.specializeWithUnknownTypeArgs = specializeWithUnknownTypeArgs;
 // Returns "Unknown" for simple TypeVars or the equivalent for a ParamSpec.
 function getUnknownTypeForTypeVar(typeVar, tupleClassType) {
-    if (typeVar.details.isParamSpec) {
+    if (typeVar.shared.isParamSpec) {
         return getUnknownTypeForParamSpec();
     }
-    if (typeVar.details.isVariadic && tupleClassType) {
+    if (typeVar.shared.isVariadic && tupleClassType) {
         return getUnknownTypeForVariadicTypeVar(tupleClassType);
     }
     return types_1.UnknownType.create();
@@ -839,21 +850,24 @@ exports.getUnknownTypeForVariadicTypeVar = getUnknownTypeForVariadicTypeVar;
 function getUnknownTypeForCallable() {
     const newFunction = types_1.FunctionType.createSynthesizedInstance('', 32768 /* FunctionTypeFlags.GradualCallableForm */);
     types_1.FunctionType.addDefaultParameters(newFunction);
-    newFunction.details.declaredReturnType = types_1.UnknownType.create();
+    newFunction.shared.declaredReturnType = types_1.UnknownType.create();
     return newFunction;
 }
 exports.getUnknownTypeForCallable = getUnknownTypeForCallable;
 // If the class is generic and not already specialized, this function
 // "self specializes" the class, filling in its own type parameters
 // as type arguments.
-function selfSpecializeClass(type, overrideTypeArgs = false) {
-    if (type.details.typeParameters.length === 0) {
+function selfSpecializeClass(type, options) {
+    if (type.shared.typeParameters.length === 0) {
         return type;
     }
-    if (type.typeArguments && !overrideTypeArgs) {
+    if (type.priv.typeArguments && !(options === null || options === void 0 ? void 0 : options.overrideTypeArgs)) {
         return type;
     }
-    return types_1.ClassType.cloneForSpecialization(type, type.details.typeParameters, /* isTypeArgumentExplicit */ true);
+    const typeParams = type.shared.typeParameters.map((typeParam) => {
+        return (options === null || options === void 0 ? void 0 : options.useInternalTypeVars) ? types_1.TypeVarType.cloneWithInternalScopeId(typeParam) : typeParam;
+    });
+    return types_1.ClassType.cloneForSpecialization(type, typeParams, /* isTypeArgumentExplicit */ true);
 }
 exports.selfSpecializeClass = selfSpecializeClass;
 // Determines whether the type derives from tuple. If so, it returns
@@ -871,7 +885,7 @@ function getSpecializedTupleType(type) {
     }
     // See if this class derives from Tuple or tuple. If it does, we'll assume that it
     // hasn't been overridden in a way that changes the behavior of the tuple class.
-    const tupleClass = classType.details.mro.find((mroClass) => (0, types_1.isInstantiableClass)(mroClass) && isTupleClass(mroClass));
+    const tupleClass = classType.shared.mro.find((mroClass) => (0, types_1.isInstantiableClass)(mroClass) && isTupleClass(mroClass));
     if (!tupleClass || !(0, types_1.isInstantiableClass)(tupleClass)) {
         return undefined;
     }
@@ -883,7 +897,7 @@ function getSpecializedTupleType(type) {
 }
 exports.getSpecializedTupleType = getSpecializedTupleType;
 function isLiteralType(type) {
-    return types_1.TypeBase.isInstance(type) && type.literalValue !== undefined;
+    return types_1.TypeBase.isInstance(type) && type.priv.literalValue !== undefined;
 }
 exports.isLiteralType = isLiteralType;
 function isLiteralTypeOrUnion(type, allowNone = false) {
@@ -891,7 +905,7 @@ function isLiteralTypeOrUnion(type, allowNone = false) {
         if (allowNone && isNoneInstance(type)) {
             return true;
         }
-        return type.literalValue !== undefined;
+        return type.priv.literalValue !== undefined;
     }
     if ((0, types_1.isUnion)(type)) {
         return !(0, types_1.findSubtype)(type, (subtype) => {
@@ -901,7 +915,7 @@ function isLiteralTypeOrUnion(type, allowNone = false) {
             if (isNoneInstance(subtype)) {
                 return !allowNone;
             }
-            return subtype.literalValue === undefined;
+            return subtype.priv.literalValue === undefined;
         });
     }
     return false;
@@ -937,8 +951,8 @@ exports.containsLiteralType = containsLiteralType;
 // it returns undefined.
 function getLiteralTypeClassName(type) {
     if ((0, types_1.isClassInstance)(type)) {
-        if (type.literalValue !== undefined && types_1.ClassType.isBuiltIn(type)) {
-            return type.details.name;
+        if (type.priv.literalValue !== undefined && types_1.ClassType.isBuiltIn(type)) {
+            return type.shared.name;
         }
         return undefined;
     }
@@ -961,13 +975,13 @@ function getLiteralTypeClassName(type) {
 exports.getLiteralTypeClassName = getLiteralTypeClassName;
 function getUnionSubtypeCount(type) {
     if ((0, types_1.isUnion)(type)) {
-        return type.subtypes.length;
+        return type.priv.subtypes.length;
     }
     return 1;
 }
 exports.getUnionSubtypeCount = getUnionSubtypeCount;
 function isEllipsisType(type) {
-    return (0, types_1.isAny)(type) && type.isEllipsis;
+    return (0, types_1.isAny)(type) && type.priv.isEllipsis;
 }
 exports.isEllipsisType = isEllipsisType;
 function isProperty(type) {
@@ -989,21 +1003,21 @@ function isCallableType(type) {
         return !!callMember;
     }
     if ((0, types_1.isUnion)(type)) {
-        return type.subtypes.every((subtype) => isCallableType(subtype));
+        return type.priv.subtypes.every((subtype) => isCallableType(subtype));
     }
     return false;
 }
 exports.isCallableType = isCallableType;
 function isDescriptorInstance(type, requireSetter = false) {
     if ((0, types_1.isUnion)(type)) {
-        return type.subtypes.every((subtype) => isMaybeDescriptorInstance(subtype, requireSetter));
+        return type.priv.subtypes.every((subtype) => isMaybeDescriptorInstance(subtype, requireSetter));
     }
     return isMaybeDescriptorInstance(type, requireSetter);
 }
 exports.isDescriptorInstance = isDescriptorInstance;
 function isMaybeDescriptorInstance(type, requireSetter = false) {
     if ((0, types_1.isUnion)(type)) {
-        return type.subtypes.some((subtype) => isMaybeDescriptorInstance(subtype, requireSetter));
+        return type.priv.subtypes.some((subtype) => isMaybeDescriptorInstance(subtype, requireSetter));
     }
     if (!(0, types_1.isClassInstance)(type)) {
         return false;
@@ -1017,6 +1031,15 @@ function isMaybeDescriptorInstance(type, requireSetter = false) {
     return true;
 }
 exports.isMaybeDescriptorInstance = isMaybeDescriptorInstance;
+function isTupleGradualForm(type) {
+    return ((0, types_1.isClassInstance)(type) &&
+        isTupleClass(type) &&
+        type.priv.tupleTypeArguments &&
+        type.priv.tupleTypeArguments.length === 1 &&
+        (0, types_1.isAnyOrUnknown)(type.priv.tupleTypeArguments[0].type) &&
+        type.priv.tupleTypeArguments[0].isUnbounded);
+}
+exports.isTupleGradualForm = isTupleGradualForm;
 function isTupleClass(type) {
     return types_1.ClassType.isBuiltIn(type, 'tuple');
 }
@@ -1025,32 +1048,30 @@ exports.isTupleClass = isTupleClass;
 // the form tuple[x, ...] where the number of elements
 // in the tuple is unknown.
 function isUnboundedTupleClass(type) {
-    return (type.tupleTypeArguments &&
-        type.tupleTypeArguments.some((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type)));
+    return (type.priv.tupleTypeArguments &&
+        type.priv.tupleTypeArguments.some((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type)));
 }
 exports.isUnboundedTupleClass = isUnboundedTupleClass;
 // Indicates whether the specified index is within range and its type is unambiguous
 // in that it doesn't involve any element ranges that are of indeterminate length.
 function isTupleIndexUnambiguous(type, index) {
-    if (!type.tupleTypeArguments) {
+    if (!type.priv.tupleTypeArguments) {
         return false;
     }
+    const unboundedIndex = type.priv.tupleTypeArguments.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type));
     if (index < 0) {
-        if (isUnboundedTupleClass(type) || type.tupleTypeArguments.length + index < 0) {
-            return false;
-        }
-    }
-    let unambiguousIndexLimit = type.tupleTypeArguments.findIndex((t) => t.isUnbounded || (0, types_1.isUnpackedVariadicTypeVar)(t.type));
-    if (unambiguousIndexLimit < 0) {
-        unambiguousIndexLimit = type.tupleTypeArguments.length;
+        const lowerIndexLimit = unboundedIndex < 0 ? 0 : unboundedIndex;
+        index += type.priv.tupleTypeArguments.length;
+        return index >= lowerIndexLimit;
     }
-    return index < unambiguousIndexLimit;
+    const upperIndexLimit = unboundedIndex < 0 ? type.priv.tupleTypeArguments.length : unboundedIndex;
+    return index < upperIndexLimit;
 }
 exports.isTupleIndexUnambiguous = isTupleIndexUnambiguous;
 // Partially specializes a type within the context of a specified
 // (presumably specialized) class. Optionally specializes the `Self`
 // type variables, replacing them with selfClass.
-function partiallySpecializeType(type, contextClassType, selfClass, typeClassType) {
+function partiallySpecializeType(type, contextClassType, typeClassType, selfClass) {
     // If the context class is not specialized (or doesn't need specialization),
     // then there's no need to do any more work.
     if (types_1.ClassType.isUnspecialized(contextClassType) && !selfClass) {
@@ -1065,20 +1086,20 @@ function partiallySpecializeType(type, contextClassType, selfClass, typeClassTyp
     // If this is a property, we may need to partially specialize the
     // access methods associated with it.
     if ((0, types_1.isClass)(result)) {
-        if (result.fgetInfo || result.fsetInfo || result.fdelInfo) {
+        if (result.priv.fgetInfo || result.priv.fsetInfo || result.priv.fdelInfo) {
             function updatePropertyMethodInfo(methodInfo) {
                 if (!methodInfo) {
                     return undefined;
                 }
                 return {
-                    methodType: partiallySpecializeType(methodInfo.methodType, contextClassType, selfClass, typeClassType),
+                    methodType: partiallySpecializeType(methodInfo.methodType, contextClassType, typeClassType, selfClass),
                     classType: methodInfo.classType,
                 };
             }
             result = types_1.TypeBase.cloneType(result);
-            result.fgetInfo = updatePropertyMethodInfo(result.fgetInfo);
-            result.fsetInfo = updatePropertyMethodInfo(result.fsetInfo);
-            result.fdelInfo = updatePropertyMethodInfo(result.fdelInfo);
+            result.priv.fgetInfo = updatePropertyMethodInfo(result.priv.fgetInfo);
+            result.priv.fsetInfo = updatePropertyMethodInfo(result.priv.fsetInfo);
+            result.priv.fdelInfo = updatePropertyMethodInfo(result.priv.fdelInfo);
         }
     }
     return result;
@@ -1091,7 +1112,7 @@ function populateTypeVarContextForSelfType(typeVarContext, contextClassType, sel
     // Instead, we'll do a simplified version of it here.
     const selfWithoutLiteral = mapSubtypes(selfInstance, (subtype) => {
         if ((0, types_1.isClass)(subtype)) {
-            if (subtype.literalValue !== undefined) {
+            if (subtype.priv.literalValue !== undefined) {
                 return types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
             }
         }
@@ -1109,6 +1130,16 @@ function ensureFunctionSignaturesAreUnique(type, signatureTracker, expressionOff
     return transformer.apply(type, 0);
 }
 exports.ensureFunctionSignaturesAreUnique = ensureFunctionSignaturesAreUnique;
+function updateTypeWithInternalTypeVars(type, scopeIds) {
+    const transformer = new InternalScopeUpdateTransform(scopeIds);
+    return transformer.apply(type, 0);
+}
+exports.updateTypeWithInternalTypeVars = updateTypeWithInternalTypeVars;
+function updateTypeWithExternalTypeVars(type, scopeIds) {
+    const transformer = new ExternalScopeUpdateTransform(scopeIds);
+    return transformer.apply(type, 0);
+}
+exports.updateTypeWithExternalTypeVars = updateTypeWithExternalTypeVars;
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 function applySolvedTypeVars(type, typeVarContext, options = {}) {
@@ -1163,7 +1194,7 @@ function applyInScopePlaceholders(typeVarContext) {
     typeVarContext.doForEachSignatureContext((signature) => {
         signature.getTypeVars().forEach((entry) => {
             const typeVar = entry.typeVar;
-            if (!typeVar.isInScopePlaceholder) {
+            if (!typeVar.priv.isInScopePlaceholder) {
                 const newNarrowTypeBound = entry.narrowBound
                     ? applyInScopePlaceholdersToType(entry.narrowBound, signature)
                     : undefined;
@@ -1193,9 +1224,9 @@ exports.applyInScopePlaceholders = applyInScopePlaceholders;
 function validateTypeVarDefault(typeVar, liveTypeParams, invalidTypeVars) {
     // If there is no default type or the default type is concrete, there's
     // no need to do any more work here.
-    if (typeVar.details.isDefaultExplicit && requiresSpecialization(typeVar.details.defaultType)) {
+    if (typeVar.shared.isDefaultExplicit && requiresSpecialization(typeVar.shared.defaultType)) {
         const validator = new TypeVarDefaultValidator(liveTypeParams, invalidTypeVars);
-        validator.apply(typeVar.details.defaultType, 0);
+        validator.apply(typeVar.shared.defaultType, 0);
     }
 }
 exports.validateTypeVarDefault = validateTypeVarDefault;
@@ -1220,7 +1251,7 @@ exports.transformExpectedType = transformExpectedType;
 // appears in a parent and a child, the child overrides the parent.
 function getProtocolSymbols(classType) {
     const symbolMap = new Map();
-    if ((classType.details.flags & 512 /* ClassTypeFlags.ProtocolClass */) !== 0) {
+    if ((classType.shared.flags & 512 /* ClassTypeFlags.ProtocolClass */) !== 0) {
         getProtocolSymbolsRecursive(classType, symbolMap, 512 /* ClassTypeFlags.ProtocolClass */);
     }
     return symbolMap;
@@ -1230,8 +1261,8 @@ function getProtocolSymbolsRecursive(classType, symbolMap, classFlags = 512 /* C
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
     }
-    classType.details.baseClasses.forEach((baseClass) => {
-        if ((0, types_1.isClass)(baseClass) && (baseClass.details.flags & classFlags) !== 0) {
+    classType.shared.baseClasses.forEach((baseClass) => {
+        if ((0, types_1.isClass)(baseClass) && (baseClass.shared.flags & classFlags) !== 0) {
             getProtocolSymbolsRecursive(baseClass, symbolMap, classFlags, recursionCount + 1);
         }
     });
@@ -1262,16 +1293,16 @@ function getContainerDepth(type, recursionCount = 0) {
         return 0;
     }
     let maxChildDepth = 0;
-    if (type.tupleTypeArguments) {
-        type.tupleTypeArguments.forEach((typeArgInfo) => {
+    if (type.priv.tupleTypeArguments) {
+        type.priv.tupleTypeArguments.forEach((typeArgInfo) => {
             doForEachSubtype(typeArgInfo.type, (subtype) => {
                 const childDepth = getContainerDepth(subtype, recursionCount);
                 maxChildDepth = Math.max(childDepth, maxChildDepth);
             });
         });
     }
-    else if (type.typeArguments) {
-        type.typeArguments.forEach((typeArg) => {
+    else if (type.priv.typeArguments) {
+        type.priv.typeArguments.forEach((typeArg) => {
             doForEachSubtype(typeArg, (subtype) => {
                 const childDepth = getContainerDepth(subtype, recursionCount);
                 maxChildDepth = Math.max(childDepth, maxChildDepth);
@@ -1296,7 +1327,7 @@ exports.lookUpObjectMember = lookUpObjectMember;
 function lookUpClassMember(classType, memberName, flags = 0 /* MemberAccessFlags.Default */, skipMroClass) {
     var _a, _b;
     // Look in the metaclass first.
-    const metaclass = classType.details.effectiveMetaclass;
+    const metaclass = classType.shared.effectiveMetaclass;
     // Skip the "type" class as an optimization because it is known to not
     // define any instance variables, and it's by far the most common metaclass.
     if (metaclass && (0, types_1.isClass)(metaclass) && !types_1.ClassType.isBuiltIn(metaclass, 'type')) {
@@ -1454,7 +1485,7 @@ exports.getClassMemberIterator = getClassMemberIterator;
 function* getClassIterator(classType, flags = 0 /* ClassIteratorFlags.Default */, skipMroClass) {
     if ((0, types_1.isClass)(classType)) {
         let foundSkipMroClass = skipMroClass === undefined;
-        for (const mroClass of classType.details.mro) {
+        for (const mroClass of classType.shared.mro) {
             // Are we still searching for the skipMroClass?
             if (!foundSkipMroClass && skipMroClass) {
                 if (!(0, types_1.isClass)(mroClass)) {
@@ -1470,7 +1501,7 @@ function* getClassIterator(classType, flags = 0 /* ClassIteratorFlags.Default */
             }
             // If mroClass is an ancestor of classType, partially specialize
             // it in the context of classType.
-            const specializedMroClass = partiallySpecializeType(mroClass, classType);
+            const specializedMroClass = partiallySpecializeType(mroClass, classType, /* typeClassType */ undefined);
             // Should we ignore members on the 'object' base class?
             if (flags & 2 /* ClassIteratorFlags.SkipObjectBaseClass */) {
                 if ((0, types_1.isInstantiableClass)(specializedMroClass)) {
@@ -1500,7 +1531,7 @@ function getClassFieldsRecursive(classType) {
     const memberMap = new Map();
     // Evaluate the types of members from the end of the MRO to the beginning.
     types_1.ClassType.getReverseMro(classType).forEach((mroClass) => {
-        const specializedMroClass = partiallySpecializeType(mroClass, classType);
+        const specializedMroClass = partiallySpecializeType(mroClass, classType, /* typeClassType */ undefined);
         if ((0, types_1.isClass)(specializedMroClass)) {
             types_1.ClassType.getSymbolTable(specializedMroClass).forEach((symbol, name) => {
                 if (!symbol.isIgnoredForProtocolMatch() && symbol.hasTypedDeclarations()) {
@@ -1530,7 +1561,7 @@ exports.getClassFieldsRecursive = getClassFieldsRecursive;
 // but removing any duplicates.
 function addTypeVarsToListIfUnique(list1, list2, typeVarScopeId) {
     for (const type2 of list2) {
-        if (typeVarScopeId && type2.scopeId !== typeVarScopeId) {
+        if (typeVarScopeId && type2.priv.scopeId !== typeVarScopeId) {
             continue;
         }
         if (!list1.find((type1) => (0, types_1.isTypeSame)(convertToInstance(type1), convertToInstance(type2)))) {
@@ -1545,32 +1576,35 @@ exports.addTypeVarsToListIfUnique = addTypeVarsToListIfUnique;
 // Union[List[Dict[_T1, _T2]], _T1, _T3], the result would be
 // [_T1, _T2, _T3].
 function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
-    var _a, _b;
+    var _a;
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return [];
     }
     recursionCount++;
-    if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) {
+    const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+    if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) {
         const combinedList = [];
-        (_b = type.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeArguments.forEach((typeArg) => {
+        aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments.forEach((typeArg) => {
             addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(typeArg, recursionCount));
         });
         return combinedList;
     }
     if ((0, types_1.isTypeVar)(type)) {
         // Don't return any recursive type alias placeholders.
-        if (type.details.recursiveTypeAliasName) {
+        if (type.shared.recursiveAlias) {
             return [];
         }
         // Don't return any P.args or P.kwargs types.
-        if ((0, types_1.isParamSpec)(type) && type.paramSpecAccess) {
+        if ((0, types_1.isParamSpec)(type) && type.priv.paramSpecAccess) {
             return [types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined)];
         }
         return [types_1.TypeBase.isInstantiable(type) ? types_1.TypeVarType.cloneAsInstance(type) : type];
     }
     if ((0, types_1.isClass)(type)) {
         const combinedList = [];
-        const typeArgs = type.tupleTypeArguments ? type.tupleTypeArguments.map((e) => e.type) : type.typeArguments;
+        const typeArgs = type.priv.tupleTypeArguments
+            ? type.priv.tupleTypeArguments.map((e) => e.type)
+            : type.priv.typeArguments;
         if (typeArgs) {
             typeArgs.forEach((typeArg) => {
                 addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(typeArg, recursionCount));
@@ -1587,7 +1621,7 @@ function getTypeVarArgumentsRecursive(type, recursionCount = 0) {
     }
     if ((0, types_1.isFunction)(type)) {
         const combinedList = [];
-        for (let i = 0; i < type.details.parameters.length; i++) {
+        for (let i = 0; i < type.shared.parameters.length; i++) {
             addTypeVarsToListIfUnique(combinedList, getTypeVarArgumentsRecursive(types_1.FunctionType.getEffectiveParameterType(type, i), recursionCount));
         }
         const returnType = types_1.FunctionType.getEffectiveReturnType(type);
@@ -1605,7 +1639,7 @@ function specializeClassType(type) {
     const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeId(type));
     const typeParams = types_1.ClassType.getTypeParameters(type);
     typeParams.forEach((typeParam) => {
-        typeVarContext.setTypeVarType(typeParam, applySolvedTypeVars(typeParam.details.defaultType, typeVarContext));
+        typeVarContext.setTypeVarType(typeParam, applySolvedTypeVars(typeParam.shared.defaultType, typeVarContext));
     });
     return applySolvedTypeVars(type, typeVarContext);
 }
@@ -1627,37 +1661,37 @@ function setTypeArgumentsRecursive(destType, srcType, typeVarContext, recursionC
             });
             break;
         case 6 /* TypeCategory.Class */:
-            if (destType.typeArguments) {
-                destType.typeArguments.forEach((typeArg) => {
+            if (destType.priv.typeArguments) {
+                destType.priv.typeArguments.forEach((typeArg) => {
                     setTypeArgumentsRecursive(typeArg, srcType, typeVarContext, recursionCount);
                 });
             }
-            if (destType.tupleTypeArguments) {
-                destType.tupleTypeArguments.forEach((typeArg) => {
+            if (destType.priv.tupleTypeArguments) {
+                destType.priv.tupleTypeArguments.forEach((typeArg) => {
                     setTypeArgumentsRecursive(typeArg.type, srcType, typeVarContext, recursionCount);
                 });
             }
             break;
         case 4 /* TypeCategory.Function */:
-            if (destType.specializedTypes) {
-                destType.specializedTypes.parameterTypes.forEach((paramType) => {
+            if (destType.priv.specializedTypes) {
+                destType.priv.specializedTypes.parameterTypes.forEach((paramType) => {
                     setTypeArgumentsRecursive(paramType, srcType, typeVarContext, recursionCount);
                 });
-                if (destType.specializedTypes.returnType) {
-                    setTypeArgumentsRecursive(destType.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
+                if (destType.priv.specializedTypes.returnType) {
+                    setTypeArgumentsRecursive(destType.priv.specializedTypes.returnType, srcType, typeVarContext, recursionCount);
                 }
             }
             else {
-                destType.details.parameters.forEach((param) => {
+                destType.shared.parameters.forEach((param) => {
                     setTypeArgumentsRecursive(param.type, srcType, typeVarContext, recursionCount);
                 });
-                if (destType.details.declaredReturnType) {
-                    setTypeArgumentsRecursive(destType.details.declaredReturnType, srcType, typeVarContext, recursionCount);
+                if (destType.shared.declaredReturnType) {
+                    setTypeArgumentsRecursive(destType.shared.declaredReturnType, srcType, typeVarContext, recursionCount);
                 }
             }
             break;
         case 5 /* TypeCategory.OverloadedFunction */:
-            destType.overloads.forEach((subtype) => {
+            destType.priv.overloads.forEach((subtype) => {
                 setTypeArgumentsRecursive(subtype, srcType, typeVarContext, recursionCount);
             });
             break;
@@ -1675,9 +1709,9 @@ exports.setTypeArgumentsRecursive = setTypeArgumentsRecursive;
 // _T1 with str and _T2 with int.
 function buildTypeVarContextFromSpecializedClass(classType) {
     const typeParameters = types_1.ClassType.getTypeParameters(classType);
-    const typeVarContext = buildTypeVarContext(typeParameters, classType.typeArguments, getTypeVarScopeId(classType));
-    if (types_1.ClassType.isTupleClass(classType) && classType.tupleTypeArguments) {
-        typeVarContext.setTupleTypeVar(typeParameters[0], classType.tupleTypeArguments);
+    const typeVarContext = buildTypeVarContext(typeParameters, classType.priv.typeArguments, getTypeVarScopeId(classType));
+    if (types_1.ClassType.isTupleClass(classType) && classType.priv.tupleTypeArguments) {
+        typeVarContext.setTupleTypeVar(typeParameters[0], classType.priv.tupleTypeArguments);
     }
     return typeVarContext;
 }
@@ -1687,21 +1721,14 @@ function buildTypeVarContext(typeParameters, typeArgs, typeVarScopeId) {
     typeParameters.forEach((typeParam, index) => {
         let typeArgType;
         if (typeArgs) {
-            if (typeParam.details.isParamSpec) {
+            if (typeParam.shared.isParamSpec) {
                 if (index < typeArgs.length) {
                     typeArgType = typeArgs[index];
                     if ((0, types_1.isFunction)(typeArgType) && types_1.FunctionType.isParamSpecValue(typeArgType)) {
                         const parameters = [];
                         const typeArgFunctionType = typeArgType;
-                        typeArgType.details.parameters.forEach((param, paramIndex) => {
-                            parameters.push({
-                                category: param.category,
-                                name: param.name,
-                                hasDefault: !!param.hasDefault,
-                                defaultValueExpression: param.defaultValueExpression,
-                                isNameSynthesized: param.isNameSynthesized,
-                                type: types_1.FunctionType.getEffectiveParameterType(typeArgFunctionType, paramIndex),
-                            });
+                        typeArgType.shared.parameters.forEach((param, paramIndex) => {
+                            parameters.push(types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParameterType(typeArgFunctionType, paramIndex), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
                         });
                         typeVarContext.setTypeVarType(typeParam, convertTypeToParamSpecValue(typeArgType));
                     }
@@ -1740,7 +1767,7 @@ function specializeForBaseClass(srcType, baseClass) {
 }
 exports.specializeForBaseClass = specializeForBaseClass;
 function derivesFromStdlibClass(classType, className) {
-    return classType.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, className));
+    return classType.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, className));
 }
 exports.derivesFromStdlibClass = derivesFromStdlibClass;
 // If ignoreUnknown is true, an unknown base class is ignored when
@@ -1750,7 +1777,7 @@ function derivesFromClassRecursive(classType, baseClassToFind, ignoreUnknown) {
     if (types_1.ClassType.isSameGenericClass(classType, baseClassToFind)) {
         return true;
     }
-    for (const baseClass of classType.details.baseClasses) {
+    for (const baseClass of classType.shared.baseClasses) {
         if ((0, types_1.isInstantiableClass)(baseClass)) {
             if (derivesFromClassRecursive(baseClass, baseClassToFind, ignoreUnknown)) {
                 return true;
@@ -1768,14 +1795,15 @@ function synthesizeTypeVarForSelfCls(classType, isClsParam) {
     var _a;
     const selfType = types_1.TypeVarType.createInstance(`__type_of_self__`);
     const scopeId = (_a = getTypeVarScopeId(classType)) !== null && _a !== void 0 ? _a : '';
-    selfType.details.isSynthesized = true;
-    selfType.details.isSynthesizedSelf = true;
-    selfType.nameWithScope = types_1.TypeVarType.makeNameWithScope(selfType.details.name, scopeId);
-    selfType.scopeId = scopeId;
-    const boundType = types_1.ClassType.cloneForSpecialization(classType, types_1.ClassType.getTypeParameters(classType), 
+    selfType.shared.isSynthesized = true;
+    selfType.shared.isSynthesizedSelf = true;
+    selfType.priv.nameWithScope = types_1.TypeVarType.makeNameWithScope(selfType.shared.name, scopeId);
+    selfType.priv.scopeId = scopeId;
+    const boundType = types_1.ClassType.cloneForSpecialization(classType, 
+    /* typeArguments */ undefined, 
     /* isTypeArgumentExplicit */ false, 
-    /* includeSubclasses */ !!classType.includeSubclasses);
-    selfType.details.boundType = types_1.ClassType.cloneAsInstance(boundType);
+    /* includeSubclasses */ !!classType.priv.includeSubclasses);
+    selfType.shared.boundType = types_1.ClassType.cloneAsInstance(boundType);
     return isClsParam ? types_1.TypeVarType.cloneAsInstantiable(selfType) : selfType;
 }
 exports.synthesizeTypeVarForSelfCls = synthesizeTypeVarForSelfCls;
@@ -1810,8 +1838,8 @@ function getGeneratorYieldType(declaredReturnType, isAsync) {
                 ['', 'AwaitableGenerator'],
             ];
             if (expectedClasses.some((classes) => types_1.ClassType.isBuiltIn(subtype, isAsync ? classes[0] : classes[1]))) {
-                return subtype.typeArguments && subtype.typeArguments.length >= 1
-                    ? subtype.typeArguments[0]
+                return subtype.priv.typeArguments && subtype.priv.typeArguments.length >= 1
+                    ? subtype.priv.typeArguments[0]
                     : types_1.UnknownType.create();
             }
         }
@@ -1823,12 +1851,12 @@ function getGeneratorYieldType(declaredReturnType, isAsync) {
 exports.getGeneratorYieldType = getGeneratorYieldType;
 function isInstantiableMetaclass(type) {
     return ((0, types_1.isInstantiableClass)(type) &&
-        type.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'type')));
+        type.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'type')));
 }
 exports.isInstantiableMetaclass = isInstantiableMetaclass;
 function isMetaclassInstance(type) {
     return ((0, types_1.isClassInstance)(type) &&
-        type.details.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'type')));
+        type.shared.mro.some((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isBuiltIn(mroClass, 'type')));
 }
 exports.isMetaclassInstance = isMetaclassInstance;
 function isEffectivelyInstantiable(type, options, recursionCount = 0) {
@@ -1839,8 +1867,8 @@ function isEffectivelyInstantiable(type, options, recursionCount = 0) {
     if (types_1.TypeBase.isInstantiable(type)) {
         return true;
     }
-    if ((options === null || options === void 0 ? void 0 : options.honorTypeVarBounds) && (0, types_1.isTypeVar)(type) && type.details.boundType) {
-        if (isEffectivelyInstantiable(type.details.boundType, options, recursionCount)) {
+    if ((options === null || options === void 0 ? void 0 : options.honorTypeVarBounds) && (0, types_1.isTypeVar)(type) && type.shared.boundType) {
+        if (isEffectivelyInstantiable(type.shared.boundType, options, recursionCount)) {
             return true;
         }
     }
@@ -1850,13 +1878,13 @@ function isEffectivelyInstantiable(type, options, recursionCount = 0) {
         return true;
     }
     if ((0, types_1.isUnion)(type)) {
-        return type.subtypes.every((subtype) => isEffectivelyInstantiable(subtype, options, recursionCount));
+        return type.priv.subtypes.every((subtype) => isEffectivelyInstantiable(subtype, options, recursionCount));
     }
     return false;
 }
 exports.isEffectivelyInstantiable = isEffectivelyInstantiable;
 function convertToInstance(type, includeSubclasses = true) {
-    var _a;
+    var _a, _b;
     // See if we've already performed this conversion and cached it.
     if (((_a = type.cached) === null || _a === void 0 ? void 0 : _a.instanceType) && includeSubclasses) {
         return type.cached.instanceType;
@@ -1867,17 +1895,17 @@ function convertToInstance(type, includeSubclasses = true) {
                 // Handle type[x] as a special case.
                 if (types_1.ClassType.isBuiltIn(subtype, 'type')) {
                     if (types_1.TypeBase.isInstance(subtype)) {
-                        if (!subtype.typeArguments || subtype.typeArguments.length < 1) {
+                        if (!subtype.priv.typeArguments || subtype.priv.typeArguments.length < 1) {
                             return types_1.UnknownType.create();
                         }
                         else {
-                            return subtype.typeArguments[0];
+                            return subtype.priv.typeArguments[0];
                         }
                     }
                     else {
-                        if (subtype.typeArguments && subtype.typeArguments.length > 0) {
-                            if (!(0, types_1.isAnyOrUnknown)(subtype.typeArguments[0])) {
-                                return convertToInstantiable(subtype.typeArguments[0]);
+                        if (subtype.priv.typeArguments && subtype.priv.typeArguments.length > 0) {
+                            if (!(0, types_1.isAnyOrUnknown)(subtype.priv.typeArguments[0])) {
+                                return convertToInstantiable(subtype.priv.typeArguments[0]);
                             }
                         }
                     }
@@ -1910,10 +1938,13 @@ function convertToInstance(type, includeSubclasses = true) {
             }
         }
         return subtype;
+    }, {
+        skipElideRedundantLiterals: true,
     });
     // Copy over any type alias information.
-    if (type.typeAliasInfo && type !== result) {
-        result = types_1.TypeBase.cloneForTypeAlias(result, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.moduleName, type.typeAliasInfo.fileUri, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, type.typeAliasInfo.typeArguments);
+    const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
+    if (aliasInfo && type !== result) {
+        result = types_1.TypeBase.cloneForTypeAlias(result, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParameters, aliasInfo.typeArguments);
     }
     if (type !== result && includeSubclasses) {
         // Cache the converted value for next time.
@@ -1956,7 +1987,7 @@ function convertToInstantiable(type, includeSubclasses = true) {
 }
 exports.convertToInstantiable = convertToInstantiable;
 function getMembersForClass(classType, symbolTable, includeInstanceVars) {
-    classType.details.mro.forEach((mroClass) => {
+    classType.shared.mro.forEach((mroClass) => {
         if ((0, types_1.isInstantiableClass)(mroClass)) {
             // Add any new member variables from this class.
             const isClassTypedDict = types_1.ClassType.isTypedDictClass(mroClass);
@@ -1981,9 +2012,9 @@ function getMembersForClass(classType, symbolTable, includeInstanceVars) {
     });
     // Add members of the metaclass as well.
     if (!includeInstanceVars) {
-        const metaclass = classType.details.effectiveMetaclass;
+        const metaclass = classType.shared.effectiveMetaclass;
         if (metaclass && (0, types_1.isInstantiableClass)(metaclass)) {
-            for (const mroClass of metaclass.details.mro) {
+            for (const mroClass of metaclass.shared.mro) {
                 if ((0, types_1.isInstantiableClass)(mroClass)) {
                     types_1.ClassType.getSymbolTable(mroClass).forEach((symbol, name) => {
                         const existingSymbol = symbolTable.get(name);
@@ -2009,12 +2040,12 @@ function getMembersForModule(moduleType, symbolTable) {
     // Start with the loader fields. If there are any symbols of the
     // same name defined within the module, they will overwrite the
     // loader fields.
-    if (moduleType.loaderFields) {
-        moduleType.loaderFields.forEach((symbol, name) => {
+    if (moduleType.priv.loaderFields) {
+        moduleType.priv.loaderFields.forEach((symbol, name) => {
             symbolTable.set(name, symbol);
         });
     }
-    moduleType.fields.forEach((symbol, name) => {
+    moduleType.priv.fields.forEach((symbol, name) => {
         symbolTable.set(name, symbol);
     });
 }
@@ -2099,8 +2130,9 @@ function isPartlyUnknown(type, recursionCount = 0) {
     }
     // If this is a generic type alias, see if any of its type arguments
     // are either unspecified or are partially known.
-    if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) {
-        if (type.typeAliasInfo.typeArguments.some((typeArg) => isPartlyUnknown(typeArg, recursionCount))) {
+    const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+    if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) {
+        if (aliasInfo.typeArguments.some((typeArg) => isPartlyUnknown(typeArg, recursionCount))) {
             return true;
         }
     }
@@ -2113,11 +2145,11 @@ function isPartlyUnknown(type, recursionCount = 0) {
         // If this is a reference to the class itself, as opposed to a reference
         // to a type that represents the class and its subclasses, don't flag
         // the type as partially unknown.
-        if (!type.includeSubclasses) {
+        if (!type.priv.includeSubclasses) {
             return false;
         }
         if (!types_1.ClassType.isPseudoGenericClass(type)) {
-            const typeArgs = ((_b = type.tupleTypeArguments) === null || _b === void 0 ? void 0 : _b.map((t) => t.type)) || type.typeArguments;
+            const typeArgs = ((_b = type.priv.tupleTypeArguments) === null || _b === void 0 ? void 0 : _b.map((t) => t.type)) || type.priv.typeArguments;
             if (typeArgs) {
                 for (const argType of typeArgs) {
                     if (isPartlyUnknown(argType, recursionCount)) {
@@ -2135,18 +2167,18 @@ function isPartlyUnknown(type, recursionCount = 0) {
         });
     }
     if ((0, types_1.isFunction)(type)) {
-        for (let i = 0; i < type.details.parameters.length; i++) {
+        for (let i = 0; i < type.shared.parameters.length; i++) {
             // Ignore parameters such as "*" that have no name.
-            if (type.details.parameters[i].name) {
+            if (type.shared.parameters[i].name) {
                 const paramType = types_1.FunctionType.getEffectiveParameterType(type, i);
                 if (isPartlyUnknown(paramType, recursionCount)) {
                     return true;
                 }
             }
         }
-        if (type.details.declaredReturnType &&
+        if (type.shared.declaredReturnType &&
             !types_1.FunctionType.isParamSpecValue(type) &&
-            isPartlyUnknown(type.details.declaredReturnType, recursionCount)) {
+            isPartlyUnknown(type.shared.declaredReturnType, recursionCount)) {
             return true;
         }
         return false;
@@ -2158,10 +2190,12 @@ exports.isPartlyUnknown = isPartlyUnknown;
 // that is a union, it "explodes" the class into a union of classes with
 // each element of the union - e.g. Foo[A | B] becomes Foo[A] | Foo[B].
 function explodeGenericClass(classType) {
-    if (!classType.typeArguments || classType.typeArguments.length !== 1 || !(0, types_1.isUnion)(classType.typeArguments[0])) {
+    if (!classType.priv.typeArguments ||
+        classType.priv.typeArguments.length !== 1 ||
+        !(0, types_1.isUnion)(classType.priv.typeArguments[0])) {
         return classType;
     }
-    return (0, types_1.combineTypes)(classType.typeArguments[0].subtypes.map((subtype) => {
+    return (0, types_1.combineTypes)(classType.priv.typeArguments[0].priv.subtypes.map((subtype) => {
         return types_1.ClassType.cloneForSpecialization(classType, [subtype], /* isTypeArgumentExplicit */ true);
     }));
 }
@@ -2183,12 +2217,12 @@ function combineSameSizedTuples(type, tupleType) {
             if (!tupleClass) {
                 // Look in the mro list to see if this subtype derives from a
                 // tuple with a known size. This includes named tuples.
-                tupleClass = subtype.details.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && isTupleClass(mroClass) && !isUnboundedTupleClass(mroClass));
+                tupleClass = subtype.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && isTupleClass(mroClass) && !isUnboundedTupleClass(mroClass));
             }
-            if (tupleClass && (0, types_1.isClass)(tupleClass) && tupleClass.tupleTypeArguments) {
+            if (tupleClass && (0, types_1.isClass)(tupleClass) && tupleClass.priv.tupleTypeArguments) {
                 if (tupleEntries) {
-                    if (tupleEntries.length === tupleClass.tupleTypeArguments.length) {
-                        tupleClass.tupleTypeArguments.forEach((entry, index) => {
+                    if (tupleEntries.length === tupleClass.priv.tupleTypeArguments.length) {
+                        tupleClass.priv.tupleTypeArguments.forEach((entry, index) => {
                             tupleEntries[index].push(entry.type);
                         });
                     }
@@ -2197,7 +2231,7 @@ function combineSameSizedTuples(type, tupleType) {
                     }
                 }
                 else {
-                    tupleEntries = tupleClass.tupleTypeArguments.map((entry) => [entry.type]);
+                    tupleEntries = tupleClass.priv.tupleTypeArguments.map((entry) => [entry.type]);
                 }
             }
             else {
@@ -2230,14 +2264,14 @@ function specializeTupleClass(classType, typeArgs, isTypeArgumentExplicit = true
     const clonedClassType = types_1.ClassType.cloneForSpecialization(classType, [combinedTupleType], isTypeArgumentExplicit, 
     /* includeSubclasses */ undefined, typeArgs);
     if (isUnpackedTuple) {
-        clonedClassType.isUnpacked = true;
+        clonedClassType.priv.isUnpacked = true;
     }
     return clonedClassType;
 }
 exports.specializeTupleClass = specializeTupleClass;
 function _expandVariadicUnpackedUnion(type) {
-    if ((0, types_1.isClassInstance)(type) && isTupleClass(type) && type.tupleTypeArguments && type.isUnpacked) {
-        return (0, types_1.combineTypes)(type.tupleTypeArguments.map((t) => t.type));
+    if ((0, types_1.isClassInstance)(type) && isTupleClass(type) && type.priv.tupleTypeArguments && type.priv.isUnpacked) {
+        return (0, types_1.combineTypes)(type.priv.tupleTypeArguments.map((t) => t.type));
     }
     return type;
 }
@@ -2247,29 +2281,29 @@ function getGeneratorTypeArgs(returnType) {
     var _a;
     if ((0, types_1.isClassInstance)(returnType)) {
         if (types_1.ClassType.isBuiltIn(returnType, ['Generator', 'AsyncGenerator'])) {
-            return returnType.typeArguments;
+            return returnType.priv.typeArguments;
         }
         else if (types_1.ClassType.isBuiltIn(returnType, 'AwaitableGenerator')) {
             // AwaitableGenerator has four type arguments, and the first 3
             // correspond to the generator.
-            return (_a = returnType.typeArguments) === null || _a === void 0 ? void 0 : _a.slice(0, 3);
+            return (_a = returnType.priv.typeArguments) === null || _a === void 0 ? void 0 : _a.slice(0, 3);
         }
     }
     return undefined;
 }
 exports.getGeneratorTypeArgs = getGeneratorTypeArgs;
 function requiresTypeArguments(classType) {
-    if (classType.details.typeParameters.length > 0) {
-        const firstTypeParam = classType.details.typeParameters[0];
+    if (classType.shared.typeParameters.length > 0) {
+        const firstTypeParam = classType.shared.typeParameters[0];
         // If there are type parameters, type arguments are needed.
         // The exception is if type parameters have been synthesized
         // for classes that have untyped constructors.
-        if (firstTypeParam.details.isSynthesized) {
+        if (firstTypeParam.shared.isSynthesized) {
             return false;
         }
         // If the first type parameter has a default type, then no
         // type arguments are needed.
-        if (firstTypeParam.details.isDefaultExplicit) {
+        if (firstTypeParam.shared.isDefaultExplicit) {
             return false;
         }
         return true;
@@ -2289,7 +2323,7 @@ function requiresTypeArguments(classType) {
             'TypeGuard',
             'TypeIs',
         ];
-        if (specialClasses.some((t) => t === (classType.aliasName || classType.details.name))) {
+        if (specialClasses.some((t) => t === (classType.priv.aliasName || classType.shared.name))) {
             return true;
         }
     }
@@ -2318,9 +2352,9 @@ function requiresSpecialization(type, options, recursionCount = 0) {
 }
 exports.requiresSpecialization = requiresSpecialization;
 function _requiresSpecialization(type, options, recursionCount = 0) {
-    var _a;
+    var _a, _b;
     // If the type is conditioned on a TypeVar, it may need to be specialized.
-    if (type.condition) {
+    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition) {
         return true;
     }
     switch (type.category) {
@@ -2328,53 +2362,54 @@ function _requiresSpecialization(type, options, recursionCount = 0) {
             if (types_1.ClassType.isPseudoGenericClass(type) && (options === null || options === void 0 ? void 0 : options.ignorePseudoGeneric)) {
                 return false;
             }
-            if (!type.isTypeArgumentExplicit && (options === null || options === void 0 ? void 0 : options.ignoreImplicitTypeArgs)) {
+            if (!type.priv.isTypeArgumentExplicit && (options === null || options === void 0 ? void 0 : options.ignoreImplicitTypeArgs)) {
                 return false;
             }
-            if (type.typeArguments) {
-                return type.typeArguments.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
+            if (type.priv.typeArguments) {
+                return type.priv.typeArguments.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
             }
             return types_1.ClassType.getTypeParameters(type).length > 0;
         }
         case 4 /* TypeCategory.Function */: {
-            for (let i = 0; i < type.details.parameters.length; i++) {
+            for (let i = 0; i < type.shared.parameters.length; i++) {
                 if (requiresSpecialization(types_1.FunctionType.getEffectiveParameterType(type, i), options, recursionCount)) {
                     return true;
                 }
             }
-            const declaredReturnType = type.specializedTypes && type.specializedTypes.returnType
-                ? type.specializedTypes.returnType
-                : type.details.declaredReturnType;
+            const declaredReturnType = type.priv.specializedTypes && type.priv.specializedTypes.returnType
+                ? type.priv.specializedTypes.returnType
+                : type.shared.declaredReturnType;
             if (declaredReturnType) {
                 if (requiresSpecialization(declaredReturnType, options, recursionCount)) {
                     return true;
                 }
             }
-            else if (type.inferredReturnType) {
-                if (requiresSpecialization(type.inferredReturnType, options, recursionCount)) {
+            else if (type.priv.inferredReturnType) {
+                if (requiresSpecialization(type.priv.inferredReturnType, options, recursionCount)) {
                     return true;
                 }
             }
             return false;
         }
         case 5 /* TypeCategory.OverloadedFunction */: {
-            return type.overloads.some((overload) => requiresSpecialization(overload, options, recursionCount));
+            return type.priv.overloads.some((overload) => requiresSpecialization(overload, options, recursionCount));
         }
         case 8 /* TypeCategory.Union */: {
-            return type.subtypes.some((subtype) => requiresSpecialization(subtype, options, recursionCount));
+            return type.priv.subtypes.some((subtype) => requiresSpecialization(subtype, options, recursionCount));
         }
         case 9 /* TypeCategory.TypeVar */: {
             // Most TypeVar types need to be specialized.
-            if (!type.details.recursiveTypeAliasName) {
-                if (type.details.isSynthesizedSelf && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
+            if (!type.shared.recursiveAlias) {
+                if (type.shared.isSynthesizedSelf && (options === null || options === void 0 ? void 0 : options.ignoreSelf)) {
                     return false;
                 }
                 return true;
             }
             // If this is a recursive type alias, it may need to be specialized
             // if it has generic type arguments.
-            if ((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) {
-                return type.typeAliasInfo.typeArguments.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
+            const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
+            if (aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments) {
+                return aliasInfo.typeArguments.some((typeArg) => requiresSpecialization(typeArg, options, recursionCount));
             }
         }
     }
@@ -2399,23 +2434,23 @@ function isVarianceOfTypeArgumentCompatible(type, typeParamVariance) {
     if (typeParamVariance === 1 /* Variance.Unknown */ || typeParamVariance === 0 /* Variance.Auto */) {
         return true;
     }
-    if ((0, types_1.isTypeVar)(type) && !type.details.isParamSpec && !type.details.isVariadic) {
-        const typeArgVariance = type.details.declaredVariance;
+    if ((0, types_1.isTypeVar)(type) && !type.shared.isParamSpec && !type.shared.isVariadic) {
+        const typeArgVariance = type.shared.declaredVariance;
         if (typeArgVariance === 4 /* Variance.Contravariant */ || typeArgVariance === 3 /* Variance.Covariant */) {
             return typeArgVariance === typeParamVariance;
         }
     }
     else if ((0, types_1.isClassInstance)(type)) {
-        if (type.details.typeParameters && type.details.typeParameters.length > 0) {
-            return type.details.typeParameters.every((typeParam, index) => {
+        if (type.shared.typeParameters && type.shared.typeParameters.length > 0) {
+            return type.shared.typeParameters.every((typeParam, index) => {
                 let typeArgType;
-                if (typeParam.details.isParamSpec || typeParam.details.isVariadic) {
+                if (typeParam.shared.isParamSpec || typeParam.shared.isVariadic) {
                     return true;
                 }
-                if (type.typeArguments && index < type.typeArguments.length) {
-                    typeArgType = type.typeArguments[index];
+                if (type.priv.typeArguments && index < type.priv.typeArguments.length) {
+                    typeArgType = type.priv.typeArguments[index];
                 }
-                const declaredVariance = typeParam.details.declaredVariance;
+                const declaredVariance = typeParam.shared.declaredVariance;
                 if (declaredVariance === 0 /* Variance.Auto */) {
                     return true;
                 }
@@ -2449,8 +2484,8 @@ exports.isVarianceOfTypeArgumentCompatible = isVarianceOfTypeArgumentCompatible;
 function computeMroLinearization(classType) {
     let isMroFound = true;
     // Clear out any existing MRO information.
-    classType.details.mro = [];
-    const filteredBaseClasses = classType.details.baseClasses.filter((baseClass, index) => {
+    classType.shared.mro = [];
+    const filteredBaseClasses = classType.shared.baseClasses.filter((baseClass, index) => {
         if ((0, types_1.isInstantiableClass)(baseClass)) {
             // Generic has some special-case logic (see description of __mro_entries__
             // in PEP 560) that we need to account for here.
@@ -2463,11 +2498,11 @@ function computeMroLinearization(classType) {
                 // If the class contains any specialized generic classes after
                 // the Generic base, the Generic base is ignored for purposes
                 // of computing the MRO.
-                if (classType.details.baseClasses.some((innerBaseClass, innerIndex) => {
+                if (classType.shared.baseClasses.some((innerBaseClass, innerIndex) => {
                     return (innerIndex > index &&
                         (0, types_1.isInstantiableClass)(innerBaseClass) &&
-                        innerBaseClass.typeArguments &&
-                        innerBaseClass.isTypeArgumentExplicit);
+                        innerBaseClass.priv.typeArguments &&
+                        innerBaseClass.priv.isTypeArgumentExplicit);
                 })) {
                     return false;
                 }
@@ -2480,7 +2515,7 @@ function computeMroLinearization(classType) {
     filteredBaseClasses.forEach((baseClass) => {
         if ((0, types_1.isInstantiableClass)(baseClass)) {
             const typeVarContext = buildTypeVarContextFromSpecializedClass(baseClass);
-            classListsToMerge.push(baseClass.details.mro.map((mroClass) => {
+            classListsToMerge.push(baseClass.shared.mro.map((mroClass) => {
                 return applySolvedTypeVars(mroClass, typeVarContext);
             }));
         }
@@ -2498,7 +2533,7 @@ function computeMroLinearization(classType) {
     if (!(0, types_1.isClass)(specializedClassType) && !(0, types_1.isAnyOrUnknown)(specializedClassType)) {
         specializedClassType = types_1.UnknownType.create();
     }
-    classType.details.mro.push(specializedClassType);
+    classType.shared.mro.push(specializedClassType);
     // Helper function that returns true if the specified searchClass
     // is found in the "tail" (i.e. in elements 1 through n) of any
     // of the class lists.
@@ -2532,13 +2567,13 @@ function computeMroLinearization(classType) {
                     if (!(0, types_1.isClass)(head) && !(0, types_1.isAnyOrUnknown)(head)) {
                         head = types_1.UnknownType.create();
                     }
-                    classType.details.mro.push(head);
+                    classType.shared.mro.push(head);
                     classList.shift();
                     break;
                 }
                 if (!isInTail(classList[0], classListsToMerge)) {
                     foundValidHead = true;
-                    classType.details.mro.push(classList[0]);
+                    classType.shared.mro.push(classList[0]);
                     filterClass(classList[0], classListsToMerge);
                     break;
                 }
@@ -2560,11 +2595,11 @@ function computeMroLinearization(classType) {
                 if (!(0, types_1.isClass)(head) && !(0, types_1.isAnyOrUnknown)(head)) {
                     head = types_1.UnknownType.create();
                 }
-                classType.details.mro.push(head);
+                classType.shared.mro.push(head);
                 nonEmptyList.shift();
             }
             else {
-                classType.details.mro.push(nonEmptyList[0]);
+                classType.shared.mro.push(nonEmptyList[0]);
                 filterClass(nonEmptyList[0], classListsToMerge);
             }
         }
@@ -2581,6 +2616,14 @@ function getDeclaringModulesForType(type) {
     return moduleList;
 }
 exports.getDeclaringModulesForType = getDeclaringModulesForType;
+function convertArgumentNodeToFunctionArgument(node) {
+    return {
+        argumentCategory: node.d.argCategory,
+        name: node.d.name,
+        valueExpression: node.d.valueExpr,
+    };
+}
+exports.convertArgumentNodeToFunctionArgument = convertArgumentNodeToFunctionArgument;
 function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
     if (recursionCount > types_1.maxTypeRecursionCount) {
         return;
@@ -2593,15 +2636,15 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
     };
     switch (type.category) {
         case 6 /* TypeCategory.Class */: {
-            addIfUnique(type.details.moduleName);
+            addIfUnique(type.shared.moduleName);
             break;
         }
         case 4 /* TypeCategory.Function */: {
-            addIfUnique(type.details.moduleName);
+            addIfUnique(type.shared.moduleName);
             break;
         }
         case 5 /* TypeCategory.OverloadedFunction */: {
-            type.overloads.forEach((overload) => {
+            type.priv.overloads.forEach((overload) => {
                 addDeclaringModuleNamesForType(overload, moduleList, recursionCount);
             });
             break;
@@ -2613,7 +2656,7 @@ function addDeclaringModuleNamesForType(type, moduleList, recursionCount = 0) {
             break;
         }
         case 7 /* TypeCategory.Module */: {
-            addIfUnique(type.moduleName);
+            addIfUnique(type.priv.moduleName);
             break;
         }
     }
@@ -2625,27 +2668,20 @@ function convertTypeToParamSpecValue(type) {
     if ((0, types_1.isParamSpec)(type)) {
         const newFunction = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */);
         types_1.FunctionType.addParamSpecVariadics(newFunction, type);
-        newFunction.details.typeVarScopeId = getTypeVarScopeId(type);
+        newFunction.shared.typeVarScopeId = getTypeVarScopeId(type);
         return newFunction;
     }
     if ((0, types_1.isFunction)(type)) {
-        const newFunction = types_1.FunctionType.createInstance('', '', '', type.details.flags | 65536 /* FunctionTypeFlags.ParamSpecValue */, type.details.docString);
-        newFunction.details.deprecatedMessage = type.details.deprecatedMessage;
-        type.details.parameters.forEach((param, index) => {
-            types_1.FunctionType.addParameter(newFunction, {
-                category: param.category,
-                name: param.name,
-                hasDefault: param.hasDefault,
-                defaultValueExpression: param.defaultValueExpression,
-                isNameSynthesized: param.isNameSynthesized,
-                type: types_1.FunctionType.getEffectiveParameterType(type, index),
-            });
+        const newFunction = types_1.FunctionType.createInstance('', '', '', type.shared.flags | 65536 /* FunctionTypeFlags.ParamSpecValue */, type.shared.docString);
+        newFunction.shared.deprecatedMessage = type.shared.deprecatedMessage;
+        type.shared.parameters.forEach((param, index) => {
+            types_1.FunctionType.addParameter(newFunction, types_1.FunctionParam.create(param.category, types_1.FunctionType.getEffectiveParameterType(type, index), param.flags & types_1.FunctionParamFlags.NameSynthesized, param.name, param.defaultType));
         });
-        if (type.details.higherOrderTypeVarScopeIds) {
-            newFunction.details.higherOrderTypeVarScopeIds = [...type.details.higherOrderTypeVarScopeIds];
-            newFunction.details.typeVarScopeId = newFunction.details.higherOrderTypeVarScopeIds.pop();
+        if (type.priv.higherOrderTypeVarScopeIds) {
+            newFunction.priv.higherOrderTypeVarScopeIds = [...type.priv.higherOrderTypeVarScopeIds];
+            newFunction.shared.typeVarScopeId = newFunction.priv.higherOrderTypeVarScopeIds.pop();
         }
-        newFunction.details.constructorTypeVarScopeId = type.details.constructorTypeVarScopeId;
+        newFunction.priv.constructorTypeVarScopeId = type.priv.constructorTypeVarScopeId;
         return newFunction;
     }
     return getUnknownTypeForParamSpec();
@@ -2656,11 +2692,11 @@ exports.convertTypeToParamSpecValue = convertTypeToParamSpecValue;
 function convertParamSpecValueToType(type) {
     const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
     const withoutParamSpec = types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type);
-    let hasParameters = withoutParamSpec.details.parameters.length > 0;
-    if (withoutParamSpec.details.parameters.length === 1) {
+    let hasParameters = withoutParamSpec.shared.parameters.length > 0;
+    if (withoutParamSpec.shared.parameters.length === 1) {
         // If the ParamSpec has a position-only separator as its only parameter,
         // treat it as though there are no parameters.
-        const onlyParam = withoutParamSpec.details.parameters[0];
+        const onlyParam = withoutParamSpec.shared.parameters[0];
         if ((0, types_1.isPositionOnlySeparator)(onlyParam)) {
             hasParameters = false;
         }
@@ -2670,27 +2706,19 @@ function convertParamSpecValueToType(type) {
         return paramSpec;
     }
     // Create a function type from the param spec entries.
-    const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | withoutParamSpec.details.flags);
-    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.details.typeVarScopeId);
-    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.details.higherOrderTypeVarScopeIds);
-    functionType.details.constructorTypeVarScopeId = withoutParamSpec.details.constructorTypeVarScopeId;
-    withoutParamSpec.details.parameters.forEach((entry, index) => {
-        types_1.FunctionType.addParameter(functionType, {
-            category: entry.category,
-            name: entry.name,
-            hasDefault: entry.hasDefault,
-            defaultValueExpression: entry.defaultValueExpression,
-            isNameSynthesized: entry.isNameSynthesized,
-            hasDeclaredType: true,
-            type: types_1.FunctionType.getEffectiveParameterType(withoutParamSpec, index),
-        });
+    const functionType = types_1.FunctionType.createInstance('', '', '', 65536 /* FunctionTypeFlags.ParamSpecValue */ | withoutParamSpec.shared.flags);
+    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.shared.typeVarScopeId);
+    types_1.FunctionType.addHigherOrderTypeVarScopeIds(functionType, withoutParamSpec.priv.higherOrderTypeVarScopeIds);
+    functionType.priv.constructorTypeVarScopeId = withoutParamSpec.priv.constructorTypeVarScopeId;
+    withoutParamSpec.shared.parameters.forEach((entry, index) => {
+        types_1.FunctionType.addParameter(functionType, types_1.FunctionParam.create(entry.category, types_1.FunctionType.getEffectiveParameterType(withoutParamSpec, index), (entry.flags & types_1.FunctionParamFlags.NameSynthesized) | types_1.FunctionParamFlags.TypeDeclared, entry.name, entry.defaultType));
     });
     if (paramSpec) {
         types_1.FunctionType.addParamSpecVariadics(functionType, paramSpec);
     }
-    functionType.details.docString = withoutParamSpec.details.docString;
-    functionType.details.deprecatedMessage = withoutParamSpec.details.deprecatedMessage;
-    functionType.details.methodClass = withoutParamSpec.details.methodClass;
+    functionType.shared.docString = withoutParamSpec.shared.docString;
+    functionType.shared.deprecatedMessage = withoutParamSpec.shared.deprecatedMessage;
+    functionType.shared.methodClass = withoutParamSpec.shared.methodClass;
     return functionType;
 }
 exports.convertParamSpecValueToType = convertParamSpecValueToType;
@@ -2703,7 +2731,7 @@ class TypeVarTransformer {
         this._pendingFunctionTransformations = [];
     }
     apply(type, recursionCount) {
-        var _a, _b;
+        var _a, _b, _c;
         if (recursionCount > types_1.maxTypeRecursionCount) {
             return type;
         }
@@ -2711,7 +2739,7 @@ class TypeVarTransformer {
         type = this.transformGenericTypeAlias(type, recursionCount);
         // If the type is conditioned on a type variable, see if the condition
         // still applies.
-        if (type.condition) {
+        if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition) {
             type = this.transformConditionalType(type, recursionCount);
         }
         // Shortcut the operation if possible.
@@ -2728,12 +2756,13 @@ class TypeVarTransformer {
             // Handle recursive type aliases specially. In particular,
             // we need to specialize type arguments for generic recursive
             // type aliases.
-            if (type.details.recursiveTypeAliasName) {
-                if (!((_a = type.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments)) {
+            const aliasInfo = (_b = type.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo;
+            if (type.shared.recursiveAlias) {
+                if (!(aliasInfo === null || aliasInfo === void 0 ? void 0 : aliasInfo.typeArguments)) {
                     return type;
                 }
                 let requiresUpdate = false;
-                const typeArgs = type.typeAliasInfo.typeArguments.map((typeArg) => {
+                const typeArgs = aliasInfo.typeArguments.map((typeArg) => {
                     const replacementType = this.apply(typeArg, recursionCount);
                     if (replacementType !== typeArg) {
                         requiresUpdate = true;
@@ -2741,7 +2770,7 @@ class TypeVarTransformer {
                     return replacementType;
                 });
                 if (requiresUpdate) {
-                    return types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.moduleName, type.typeAliasInfo.fileUri, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, typeArgs);
+                    return types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParameters, typeArgs);
                 }
                 return type;
             }
@@ -2749,18 +2778,18 @@ class TypeVarTransformer {
             // Recursively transform the results, but ensure that we don't replace any
             // type variables in the same scope recursively by setting it the scope in the
             // _pendingTypeVarTransformations set.
-            if (!this._isTypeVarScopePending(type.scopeId)) {
-                if (type.details.isParamSpec) {
+            if (!this._isTypeVarScopePending(type.priv.scopeId)) {
+                if (type.shared.isParamSpec) {
                     let paramSpecWithoutAccess = type;
-                    if (type.paramSpecAccess) {
+                    if (type.priv.paramSpecAccess) {
                         paramSpecWithoutAccess = types_1.TypeVarType.cloneForParamSpecAccess(type, /* access */ undefined);
                     }
                     const paramSpecValue = this.transformParamSpec(paramSpecWithoutAccess, recursionCount);
                     if (paramSpecValue) {
                         const paramSpecType = convertParamSpecValueToType(paramSpecValue);
-                        if (type.paramSpecAccess) {
+                        if (type.priv.paramSpecAccess) {
                             if ((0, types_1.isParamSpec)(paramSpecType)) {
-                                replacementType = types_1.TypeVarType.cloneForParamSpecAccess(paramSpecType, type.paramSpecAccess);
+                                replacementType = types_1.TypeVarType.cloneForParamSpecAccess(paramSpecType, type.priv.paramSpecAccess);
                             }
                             else {
                                 replacementType = types_1.UnknownType.create();
@@ -2772,19 +2801,19 @@ class TypeVarTransformer {
                     }
                 }
                 else {
-                    replacementType = (_b = this.transformTypeVar(type, recursionCount)) !== null && _b !== void 0 ? _b : type;
+                    replacementType = (_c = this.transformTypeVar(type, recursionCount)) !== null && _c !== void 0 ? _c : type;
                     if (!this._isTransformingTypeArg) {
-                        if (type.scopeId) {
-                            this._pendingTypeVarTransformations.add(type.scopeId);
+                        if (type.priv.scopeId) {
+                            this._pendingTypeVarTransformations.add(type.priv.scopeId);
                         }
                         replacementType = this.apply(replacementType, recursionCount);
-                        if (type.scopeId) {
-                            this._pendingTypeVarTransformations.delete(type.scopeId);
+                        if (type.priv.scopeId) {
+                            this._pendingTypeVarTransformations.delete(type.priv.scopeId);
                         }
                     }
                     // If we're transforming a variadic type variable that was in a union,
                     // expand the union types.
-                    if ((0, types_1.isVariadicTypeVar)(type) && type.isVariadicInUnion) {
+                    if ((0, types_1.isVariadicTypeVar)(type) && type.priv.isVariadicInUnion) {
                         replacementType = _expandVariadicUnpackedUnion(replacementType);
                     }
                 }
@@ -2807,7 +2836,7 @@ class TypeVarTransformer {
                     return this.transformUnionSubtype(subtype, transformedType, recursionCount);
                 }
                 return transformedType;
-            });
+            }, { retainTypeAlias: true });
             return !(0, types_1.isNever)(newUnionType) ? newUnionType : types_1.UnknownType.create();
         }
         if ((0, types_1.isClass)(type)) {
@@ -2832,13 +2861,13 @@ class TypeVarTransformer {
             let requiresUpdate = false;
             // Specialize each of the functions in the overload.
             const newOverloads = [];
-            type.overloads.forEach((entry) => {
+            type.priv.overloads.forEach((entry) => {
                 const replacementType = this.transformTypeVarsInFunctionType(entry, recursionCount);
                 if ((0, types_1.isFunction)(replacementType)) {
                     newOverloads.push(replacementType);
                 }
                 else {
-                    (0, collectionUtils_1.appendArray)(newOverloads, replacementType.overloads);
+                    (0, collectionUtils_1.appendArray)(newOverloads, replacementType.priv.overloads);
                 }
                 if (replacementType !== entry) {
                     requiresUpdate = true;
@@ -2868,11 +2897,13 @@ class TypeVarTransformer {
         return callback();
     }
     transformGenericTypeAlias(type, recursionCount) {
-        if (!type.typeAliasInfo || !type.typeAliasInfo.typeParameters || !type.typeAliasInfo.typeArguments) {
+        var _a;
+        const aliasInfo = (_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo;
+        if (!aliasInfo || !aliasInfo.typeParameters || !aliasInfo.typeArguments) {
             return type;
         }
         let requiresUpdate = false;
-        const newTypeArgs = type.typeAliasInfo.typeArguments.map((typeArg) => {
+        const newTypeArgs = aliasInfo.typeArguments.map((typeArg) => {
             const updatedType = this.apply(typeArg, recursionCount);
             if (type !== updatedType) {
                 requiresUpdate = true;
@@ -2880,7 +2911,7 @@ class TypeVarTransformer {
             return updatedType;
         });
         return requiresUpdate
-            ? types_1.TypeBase.cloneForTypeAlias(type, type.typeAliasInfo.name, type.typeAliasInfo.fullName, type.typeAliasInfo.moduleName, type.typeAliasInfo.fileUri, type.typeAliasInfo.typeVarScopeId, type.typeAliasInfo.isPep695Syntax, type.typeAliasInfo.typeParameters, newTypeArgs)
+            ? types_1.TypeBase.cloneForTypeAlias(type, aliasInfo.name, aliasInfo.fullName, aliasInfo.moduleName, aliasInfo.fileUri, aliasInfo.typeVarScopeId, aliasInfo.isPep695Syntax, aliasInfo.typeParameters, newTypeArgs)
             : type;
     }
     transformConditionalType(type, recursionCount) {
@@ -2913,9 +2944,9 @@ class TypeVarTransformer {
         // If type args were previously provided, specialize them.
         // Handle tuples specially.
         if (types_1.ClassType.isTupleClass(classType)) {
-            if (classType.tupleTypeArguments) {
+            if (classType.priv.tupleTypeArguments) {
                 newTupleTypeArgs = [];
-                classType.tupleTypeArguments.forEach((oldTypeArgType) => {
+                classType.priv.tupleTypeArguments.forEach((oldTypeArgType) => {
                     const newTypeArgType = this.apply(oldTypeArgType.type, recursionCount);
                     if (newTypeArgType !== oldTypeArgType.type) {
                         specializationNeeded = true;
@@ -2923,8 +2954,8 @@ class TypeVarTransformer {
                     if ((0, types_1.isUnpackedVariadicTypeVar)(oldTypeArgType.type) &&
                         (0, types_1.isClassInstance)(newTypeArgType) &&
                         isTupleClass(newTypeArgType) &&
-                        newTypeArgType.tupleTypeArguments) {
-                        (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.tupleTypeArguments);
+                        newTypeArgType.priv.tupleTypeArguments) {
+                        (0, collectionUtils_1.appendArray)(newTupleTypeArgs, newTypeArgType.priv.tupleTypeArguments);
                     }
                     else {
                         // Handle the special case where tuple[T, ...] is being specialized
@@ -2932,7 +2963,7 @@ class TypeVarTransformer {
                         const isEmptyTuple = oldTypeArgType.isUnbounded &&
                             (0, types_1.isTypeVar)(oldTypeArgType.type) &&
                             (0, types_1.isNever)(newTypeArgType) &&
-                            classType.tupleTypeArguments.length === 1;
+                            classType.priv.tupleTypeArguments.length === 1;
                         if (!isEmptyTuple) {
                             newTupleTypeArgs.push({
                                 type: newTypeArgType,
@@ -2969,9 +3000,9 @@ class TypeVarTransformer {
             }
         }
         if (!newTypeArgs) {
-            if (classType.typeArguments) {
-                newTypeArgs = classType.typeArguments.map((oldTypeArgType) => {
-                    if ((0, types_1.isTypeVar)(oldTypeArgType) && oldTypeArgType.details.isParamSpec) {
+            if (classType.priv.typeArguments) {
+                newTypeArgs = classType.priv.typeArguments.map((oldTypeArgType) => {
+                    if ((0, types_1.isTypeVar)(oldTypeArgType) && oldTypeArgType.shared.isParamSpec) {
                         return transformParamSpec(oldTypeArgType);
                     }
                     let newTypeArgType = this.apply(oldTypeArgType, recursionCount);
@@ -2981,7 +3012,7 @@ class TypeVarTransformer {
                         // (e.g. Union[Unpack[Vs]]), expand the subtypes into a union here.
                         if ((0, types_1.isTypeVar)(oldTypeArgType) &&
                             (0, types_1.isVariadicTypeVar)(oldTypeArgType) &&
-                            oldTypeArgType.isVariadicInUnion) {
+                            oldTypeArgType.priv.isVariadicInUnion) {
                             newTypeArgType = _expandVariadicUnpackedUnion(newTypeArgType);
                         }
                     }
@@ -2992,20 +3023,20 @@ class TypeVarTransformer {
                 newTypeArgs = [];
                 typeParams.forEach((typeParam) => {
                     let replacementType = typeParam;
-                    if (typeParam.details.isParamSpec) {
+                    if (typeParam.shared.isParamSpec) {
                         replacementType = transformParamSpec(typeParam);
                         if (replacementType !== typeParam) {
                             specializationNeeded = true;
                         }
                     }
                     else {
-                        if (!this._isTypeVarScopePending(typeParam.scopeId)) {
+                        if (!this._isTypeVarScopePending(typeParam.priv.scopeId)) {
                             const transformedType = this.transformTypeVar(typeParam, recursionCount);
                             replacementType = transformedType !== null && transformedType !== void 0 ? transformedType : typeParam;
                             if (replacementType !== typeParam) {
                                 specializationNeeded = true;
                             }
-                            else if (transformedType !== undefined && !classType.typeArguments) {
+                            else if (transformedType !== undefined && !classType.priv.typeArguments) {
                                 specializationNeeded = true;
                             }
                         }
@@ -3033,6 +3064,7 @@ class TypeVarTransformer {
             let typesRequiredSpecialization = declaredReturnType !== specializedReturnType;
             const specializedParameters = {
                 parameterTypes: [],
+                parameterDefaultArgs: undefined,
                 returnType: specializedReturnType,
             };
             const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(functionType);
@@ -3040,7 +3072,7 @@ class TypeVarTransformer {
                 const paramSpecType = this.transformParamSpec(paramSpec, recursionCount);
                 if (paramSpecType) {
                     const transformedParamSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(paramSpecType);
-                    if (paramSpecType.details.parameters.length > 0 ||
+                    if (paramSpecType.shared.parameters.length > 0 ||
                         !transformedParamSpec ||
                         !(0, types_1.isTypeSame)(paramSpec, transformedParamSpec)) {
                         functionType = types_1.FunctionType.applyParamSpecValue(functionType, paramSpecType);
@@ -3052,7 +3084,7 @@ class TypeVarTransformer {
             const specializedDefaultArgs = [];
             const wasTransformingTypeArg = this._isTransformingTypeArg;
             this._isTransformingTypeArg = true;
-            for (let i = 0; i < functionType.details.parameters.length; i++) {
+            for (let i = 0; i < functionType.shared.parameters.length; i++) {
                 const paramType = types_1.FunctionType.getEffectiveParameterType(functionType, i);
                 const specializedType = this.apply(paramType, recursionCount);
                 specializedParameters.parameterTypes.push(specializedType);
@@ -3068,12 +3100,12 @@ class TypeVarTransformer {
                 specializedDefaultArgs.push(defaultArgType);
                 if (variadicParamIndex === undefined &&
                     (0, types_1.isVariadicTypeVar)(paramType) &&
-                    functionType.details.parameters[i].category === 1 /* ParameterCategory.ArgsList */) {
+                    functionType.shared.parameters[i].category === 1 /* ParameterCategory.ArgsList */) {
                     variadicParamIndex = i;
                     if ((0, types_1.isClassInstance)(specializedType) &&
                         isTupleClass(specializedType) &&
-                        specializedType.isUnpacked) {
-                        variadicTypesToUnpack = specializedType.tupleTypeArguments;
+                        specializedType.priv.isUnpacked) {
+                        variadicTypesToUnpack = specializedType.priv.tupleTypeArguments;
                     }
                 }
                 if (paramType !== specializedType) {
@@ -3081,12 +3113,27 @@ class TypeVarTransformer {
                 }
             }
             let specializedInferredReturnType;
-            if (functionType.inferredReturnType) {
-                specializedInferredReturnType = this.apply(functionType.inferredReturnType, recursionCount);
-                if (specializedInferredReturnType !== functionType.inferredReturnType) {
+            if (functionType.priv.inferredReturnType) {
+                specializedInferredReturnType = this.apply(functionType.priv.inferredReturnType, recursionCount);
+                if (specializedInferredReturnType !== functionType.priv.inferredReturnType) {
                     typesRequiredSpecialization = true;
                 }
             }
+            // Do we need to update the boundToType?
+            if (functionType.priv.boundToType) {
+                const newBoundToType = this.apply(functionType.priv.boundToType, recursionCount);
+                if (newBoundToType !== functionType.priv.boundToType && (0, types_1.isClass)(newBoundToType)) {
+                    functionType = types_1.FunctionType.clone(functionType, /* stripFirstParam */ false, newBoundToType);
+                }
+            }
+            // Do we need to update the strippedFirstParamType?
+            if (functionType.priv.strippedFirstParamType) {
+                const newStrippedType = this.apply(functionType.priv.strippedFirstParamType, recursionCount);
+                if (newStrippedType !== functionType.priv.strippedFirstParamType) {
+                    functionType = types_1.TypeBase.cloneType(functionType);
+                    functionType.priv.strippedFirstParamType = newStrippedType;
+                }
+            }
             this._isTransformingTypeArg = wasTransformingTypeArg;
             if (!typesRequiredSpecialization) {
                 return functionType;
@@ -3100,8 +3147,8 @@ class TypeVarTransformer {
             }
             // Unpack the tuple and synthesize a new function in the process.
             const newFunctionType = types_1.TypeBase.isInstantiable(functionType)
-                ? types_1.FunctionType.createInstantiable(functionType.details.flags | 64 /* FunctionTypeFlags.SynthesizedMethod */)
-                : types_1.FunctionType.createSynthesizedInstance('', functionType.details.flags);
+                ? types_1.FunctionType.createInstantiable(functionType.shared.flags | 64 /* FunctionTypeFlags.SynthesizedMethod */)
+                : types_1.FunctionType.createSynthesizedInstance('', functionType.shared.flags);
             let insertKeywordOnlySeparator = false;
             let swallowPositionOnlySeparator = false;
             specializedParameters.parameterTypes.forEach((paramType, index) => {
@@ -3109,15 +3156,9 @@ class TypeVarTransformer {
                     let sawUnboundedEntry = false;
                     // Unpack the tuple into individual parameters.
                     variadicTypesToUnpack.forEach((unpackedType) => {
-                        types_1.FunctionType.addParameter(newFunctionType, {
-                            category: unpackedType.isUnbounded || (0, types_1.isVariadicTypeVar)(unpackedType.type)
-                                ? 1 /* ParameterCategory.ArgsList */
-                                : 0 /* ParameterCategory.Simple */,
-                            name: `__p${newFunctionType.details.parameters.length}`,
-                            isNameSynthesized: true,
-                            type: unpackedType.type,
-                            hasDeclaredType: true,
-                        });
+                        types_1.FunctionType.addParameter(newFunctionType, types_1.FunctionParam.create(unpackedType.isUnbounded || (0, types_1.isVariadicTypeVar)(unpackedType.type)
+                            ? 1 /* ParameterCategory.ArgsList */
+                            : 0 /* ParameterCategory.Simple */, unpackedType.type, types_1.FunctionParamFlags.NameSynthesized | types_1.FunctionParamFlags.TypeDeclared, `__p${newFunctionType.shared.parameters.length}`));
                         if (unpackedType.isUnbounded) {
                             sawUnboundedEntry = true;
                         }
@@ -3130,7 +3171,7 @@ class TypeVarTransformer {
                     }
                 }
                 else {
-                    const param = { ...functionType.details.parameters[index] };
+                    const param = { ...functionType.shared.parameters[index] };
                     if ((0, types_1.isKeywordOnlySeparator)(param)) {
                         insertKeywordOnlySeparator = false;
                     }
@@ -3144,15 +3185,15 @@ class TypeVarTransformer {
                         insertKeywordOnlySeparator = false;
                     }
                     param.type = paramType;
-                    if (param.name && param.isNameSynthesized) {
-                        param.name = `__p${newFunctionType.details.parameters.length}`;
+                    if (param.name && types_1.FunctionParam.isNameSynthesized(param)) {
+                        param.name = `__p${newFunctionType.shared.parameters.length}`;
                     }
                     if (param.category !== 0 /* ParameterCategory.Simple */ || param.name || !swallowPositionOnlySeparator) {
                         types_1.FunctionType.addParameter(newFunctionType, param);
                     }
                 }
             });
-            newFunctionType.details.declaredReturnType = specializedParameters.returnType;
+            newFunctionType.shared.declaredReturnType = specializedParameters.returnType;
             return newFunctionType;
         });
     }
@@ -3181,16 +3222,16 @@ class TypeVarDefaultValidator extends TypeVarTransformer {
         this._invalidTypeVars = _invalidTypeVars;
     }
     transformTypeVar(typeVar) {
-        const replacementType = this._liveTypeParams.find((param) => param.details.name === typeVar.details.name);
+        const replacementType = this._liveTypeParams.find((param) => param.shared.name === typeVar.shared.name);
         if (!replacementType || (0, types_1.isParamSpec)(replacementType)) {
-            this._invalidTypeVars.add(typeVar.details.name);
+            this._invalidTypeVars.add(typeVar.shared.name);
         }
         return types_1.UnknownType.create();
     }
     transformParamSpec(paramSpec) {
-        const replacementType = this._liveTypeParams.find((param) => param.details.name === paramSpec.details.name);
+        const replacementType = this._liveTypeParams.find((param) => param.shared.name === paramSpec.shared.name);
         if (!replacementType || !(0, types_1.isParamSpec)(replacementType)) {
-            this._invalidTypeVars.add(paramSpec.details.name);
+            this._invalidTypeVars.add(paramSpec.shared.name);
         }
         return undefined;
     }
@@ -3210,11 +3251,8 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
         return classType;
     }
     transformTypeVarsInFunctionType(sourceType, recursionCount) {
-        if (sourceType.trackedSignatures) {
-            this._signatureTracker.addTrackedSignatures(sourceType.trackedSignatures);
-        }
         // If this function is not generic, there's no need to check for uniqueness.
-        if (sourceType.details.typeParameters.length === 0) {
+        if (sourceType.shared.typeParameters.length === 0) {
             return super.transformTypeVarsInFunctionType(sourceType, recursionCount);
         }
         let updatedSourceType = sourceType;
@@ -3228,10 +3266,10 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
                 const typeVarContext = new typeVarContext_1.TypeVarContext(getTypeVarScopeIds(sourceType));
                 // Create new type variables with the same scope but with
                 // different (unique) names.
-                sourceType.details.typeParameters.forEach((typeParam) => {
-                    if (typeParam.scopeType === 1 /* TypeVarScopeType.Function */) {
-                        let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.details.name}(${offsetIndex})`);
-                        if (replacement.details.isParamSpec) {
+                sourceType.shared.typeParameters.forEach((typeParam) => {
+                    if (typeParam.priv.scopeType === 1 /* TypeVarScopeType.Function */) {
+                        let replacement = types_1.TypeVarType.cloneForNewName(typeParam, `${typeParam.shared.name}(${offsetIndex})`);
+                        if (replacement.shared.isParamSpec) {
                             replacement = convertTypeToParamSpecValue(replacement);
                         }
                         typeVarContext.setTypeVarType(typeParam, replacement);
@@ -3245,6 +3283,58 @@ class UniqueFunctionSignatureTransformer extends TypeVarTransformer {
         return updatedSourceType;
     }
 }
+// Replaces the TypeVars within a type with their corresponding "internal"
+// types if they are in one of the specified scopes.
+class InternalScopeUpdateTransform extends TypeVarTransformer {
+    constructor(_scopeIds) {
+        super();
+        this._scopeIds = _scopeIds;
+    }
+    transformTypeVar(typeVar) {
+        if (this._isTypeVarInScope(typeVar)) {
+            return this._replaceTypeVar(typeVar);
+        }
+        return undefined;
+    }
+    transformParamSpec(paramSpec) {
+        if (this._isTypeVarInScope(paramSpec)) {
+            return convertTypeToParamSpecValue(this._replaceTypeVar(paramSpec));
+        }
+        return undefined;
+    }
+    _isTypeVarInScope(typeVar) {
+        return typeVar.priv.scopeId !== undefined && this._scopeIds.includes(typeVar.priv.scopeId);
+    }
+    _replaceTypeVar(typeVar) {
+        return types_1.TypeVarType.cloneWithInternalScopeId(typeVar);
+    }
+}
+// Replaces the internal TypeVars within a type with their corresponding
+// "external" types.
+class ExternalScopeUpdateTransform extends TypeVarTransformer {
+    constructor(_scopeIds) {
+        super();
+        this._scopeIds = _scopeIds;
+    }
+    transformTypeVar(typeVar) {
+        if (typeVar.priv.externalTypeVar && this._isTypeVarInScope(typeVar.priv.externalTypeVar)) {
+            return typeVar.priv.externalTypeVar;
+        }
+        return undefined;
+    }
+    transformParamSpec(paramSpec) {
+        if (paramSpec.priv.externalTypeVar && this._isTypeVarInScope(paramSpec.priv.externalTypeVar)) {
+            return convertTypeToParamSpecValue(paramSpec.priv.externalTypeVar);
+        }
+        return undefined;
+    }
+    _isTypeVarInScope(typeVar) {
+        if (!typeVar.priv.scopeId) {
+            return false;
+        }
+        return this._scopeIds.includes(typeVar.priv.scopeId);
+    }
+}
 // Specializes a (potentially generic) type by substituting
 // type variables from a type var map.
 class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
@@ -3259,7 +3349,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
         // If the type variable is unrelated to the scopes we're solving,
         // don't transform that type variable.
-        if (typeVar.scopeId && this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
+        if (typeVar.priv.scopeId && this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
             let replacement = signatureContext.getTypeVarType(typeVar, !!this._options.useNarrowBoundOnly);
             // If there was no narrow bound but there is a wide bound that
             // contains literals or a TypeVar, we'll use the wide bound even if
@@ -3293,22 +3383,26 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                         if ((0, types_1.isClassInstance)(subtype)) {
                             // If the includeSubclasses wasn't set, force it to be set by
                             // converting to/from an instantiable.
-                            if (!subtype.includeSubclasses) {
+                            if (!subtype.priv.includeSubclasses) {
                                 subtype = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneAsInstantiable(subtype));
                             }
-                            if (this._options.unknownIfNotFound) {
-                                return this._options.useUnknownOverDefault
-                                    ? specializeWithUnknownTypeArgs(subtype, this._options.tupleClassType)
-                                    : specializeWithDefaultTypeArgs(subtype);
+                            if (subtype.shared.typeParameters && !subtype.priv.typeArguments) {
+                                if (this._options.unknownIfNotFound) {
+                                    return this._options.useUnknownOverDefault
+                                        ? specializeWithUnknownTypeArgs(subtype, this._options.tupleClassType)
+                                        : specializeWithDefaultTypeArgs(subtype);
+                                }
                             }
                         }
                         return subtype;
                     });
                 }
-                if ((0, types_1.isTypeVar)(replacement) && typeVar.isVariadicUnpacked && replacement.details.isVariadic) {
-                    return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.isVariadicInUnion);
+                if ((0, types_1.isTypeVar)(replacement) && typeVar.priv.isVariadicUnpacked && replacement.shared.isVariadic) {
+                    return types_1.TypeVarType.cloneForUnpacked(replacement, typeVar.priv.isVariadicInUnion);
                 }
-                if (!(0, types_1.isTypeVar)(replacement) || !replacement.isInScopePlaceholder || !this._options.unknownIfNotFound) {
+                if (!(0, types_1.isTypeVar)(replacement) ||
+                    !replacement.priv.isInScopePlaceholder ||
+                    !this._options.unknownIfNotFound) {
                     return replacement;
                 }
             }
@@ -3323,27 +3417,27 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                     useDefaultOrUnknown = true;
                 }
             }
-            else if (this._options.applyInScopePlaceholders && typeVar.isInScopePlaceholder) {
+            else if (this._options.applyInScopePlaceholders && typeVar.priv.isInScopePlaceholder) {
                 useDefaultOrUnknown = true;
             }
             if (useDefaultOrUnknown) {
                 // Use the default value if there is one.
-                if (typeVar.details.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                    return this._solveDefaultType(typeVar.details.defaultType, recursionCount);
+                if (typeVar.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
+                    return this._solveDefaultType(typeVar, recursionCount);
                 }
                 return getUnknownTypeForTypeVar(typeVar, this._options.tupleClassType);
             }
         }
         // If we're solving a default type, handle type variables with no scope ID.
-        if (this._isSolvingDefaultType && !typeVar.scopeId) {
+        if (this._isSolvingDefaultType && !typeVar.priv.scopeId) {
             const replacementEntry = signatureContext
                 .getTypeVars()
-                .find((entry) => entry.typeVar.details.name === typeVar.details.name);
+                .find((entry) => entry.typeVar.shared.name === typeVar.shared.name);
             if (replacementEntry) {
                 return signatureContext.getTypeVarType(replacementEntry.typeVar);
             }
-            if (typeVar.details.isDefaultExplicit) {
-                return this.apply(typeVar.details.defaultType, recursionCount);
+            if (typeVar.shared.isDefaultExplicit) {
+                return this.apply(typeVar.shared.defaultType, recursionCount);
             }
             return types_1.UnknownType.create();
         }
@@ -3358,12 +3452,12 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         //   def test(x: Union[str, T]) -> Union[str, T]
         if (this._options.eliminateUnsolvedInUnions) {
             if ((0, types_1.isTypeVar)(preTransform) &&
-                preTransform.scopeId !== undefined &&
-                this._typeVarContext.hasSolveForScope(preTransform.scopeId)) {
+                preTransform.priv.scopeId !== undefined &&
+                this._typeVarContext.hasSolveForScope(preTransform.priv.scopeId)) {
                 const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
                 const typeVarType = signatureContext.getTypeVarType(preTransform);
                 // Did the TypeVar remain unsolved?
-                if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && typeVarType.isInScopePlaceholder)) {
+                if (!typeVarType || ((0, types_1.isTypeVar)(typeVarType) && typeVarType.priv.isInScopePlaceholder)) {
                     // If the TypeVar was not transformed, then it was unsolved,
                     // and we'll eliminate it.
                     if (preTransform === postTransform) {
@@ -3381,10 +3475,12 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
     }
     transformTupleTypeVar(typeVar) {
         var _a;
-        if (!typeVar.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.scopeId)) {
-            const defaultType = typeVar.details.defaultType;
-            if (typeVar.details.isDefaultExplicit && (0, types_1.isClassInstance)(defaultType) && defaultType.tupleTypeArguments) {
-                return defaultType.tupleTypeArguments;
+        if (!typeVar.priv.scopeId || !this._typeVarContext.hasSolveForScope(typeVar.priv.scopeId)) {
+            const defaultType = typeVar.shared.defaultType;
+            if (typeVar.shared.isDefaultExplicit &&
+                (0, types_1.isClassInstance)(defaultType) &&
+                defaultType.priv.tupleTypeArguments) {
+                return defaultType.priv.tupleTypeArguments;
             }
             return undefined;
         }
@@ -3395,19 +3491,19 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         var _a, _b;
         const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
         // If we're solving a default type, handle param specs with no scope ID.
-        if (this._isSolvingDefaultType && !paramSpec.scopeId) {
+        if (this._isSolvingDefaultType && !paramSpec.priv.scopeId) {
             const replacementEntry = signatureContext
                 .getTypeVars()
-                .find((entry) => entry.typeVar.details.name === paramSpec.details.name);
+                .find((entry) => entry.typeVar.shared.name === paramSpec.shared.name);
             if (replacementEntry) {
                 return signatureContext.getParamSpecType(replacementEntry.typeVar);
             }
-            if (paramSpec.details.isDefaultExplicit) {
-                return convertTypeToParamSpecValue(this.apply(paramSpec.details.defaultType, recursionCount));
+            if (paramSpec.shared.isDefaultExplicit) {
+                return convertTypeToParamSpecValue(this.apply(paramSpec.shared.defaultType, recursionCount));
             }
             return getUnknownTypeForParamSpec();
         }
-        if (!paramSpec.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.scopeId)) {
+        if (!paramSpec.priv.scopeId || !this._typeVarContext.hasSolveForScope(paramSpec.priv.scopeId)) {
             return undefined;
         }
         const transformedParamSpec = signatureContext.getParamSpecType(paramSpec);
@@ -3421,13 +3517,13 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
                 useDefaultOrUnknown = true;
             }
         }
-        else if (this._options.applyInScopePlaceholders && paramSpec.isInScopePlaceholder) {
+        else if (this._options.applyInScopePlaceholders && paramSpec.priv.isInScopePlaceholder) {
             useDefaultOrUnknown = true;
         }
         if (useDefaultOrUnknown) {
             // Use the default value if there is one.
-            if (paramSpec.details.isDefaultExplicit && !this._options.useUnknownOverDefault) {
-                return convertTypeToParamSpecValue(this._solveDefaultType(paramSpec.details.defaultType, recursionCount));
+            if (paramSpec.shared.isDefaultExplicit && !this._options.useUnknownOverDefault) {
+                return convertTypeToParamSpecValue(this._solveDefaultType(paramSpec, recursionCount));
             }
             // Convert to the ParamSpec equivalent of "Unknown".
             return getUnknownTypeForParamSpec();
@@ -3435,25 +3531,26 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         return undefined;
     }
     transformConditionalType(type, recursionCount) {
-        var _a;
-        if (!type.condition) {
+        var _a, _b, _c, _d;
+        if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition)) {
             return type;
         }
-        const signatureContext = this._typeVarContext.getSignatureContext((_a = this._activeTypeVarSignatureContextIndex) !== null && _a !== void 0 ? _a : 0);
-        for (const condition of type.condition) {
+        const signatureContext = this._typeVarContext.getSignatureContext((_b = this._activeTypeVarSignatureContextIndex) !== null && _b !== void 0 ? _b : 0);
+        for (const condition of type.props.condition) {
             // This doesn't apply to bound type variables.
-            if (condition.typeVar.details.constraints.length === 0) {
+            if (condition.typeVar.shared.constraints.length === 0) {
                 continue;
             }
-            const typeVarEntry = signatureContext.getTypeVar(condition.typeVar);
-            if (!typeVarEntry || condition.constraintIndex >= typeVarEntry.typeVar.details.constraints.length) {
+            const conditionTypeVar = (_d = (_c = condition.typeVar.priv) === null || _c === void 0 ? void 0 : _c.externalTypeVar) !== null && _d !== void 0 ? _d : condition.typeVar;
+            const typeVarEntry = signatureContext.getTypeVar(conditionTypeVar);
+            if (!typeVarEntry || condition.constraintIndex >= typeVarEntry.typeVar.shared.constraints.length) {
                 continue;
             }
             const value = signatureContext.getTypeVarType(typeVarEntry.typeVar);
             if (!value) {
                 continue;
             }
-            const constraintType = typeVarEntry.typeVar.details.constraints[condition.constraintIndex];
+            const constraintType = typeVarEntry.typeVar.shared.constraints[condition.constraintIndex];
             // If this violates the constraint, substitute a Never type.
             if (!(0, types_1.isTypeSame)(constraintType, value)) {
                 return types_1.NeverType.createNever();
@@ -3477,7 +3574,7 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         const filteredOverloads = [];
         doForEachSubtype((0, types_1.combineTypes)(overloadTypes), (subtype) => {
             (0, debug_1.assert)((0, types_1.isFunction)(subtype));
-            subtype = types_1.FunctionType.cloneWithNewFlags(subtype, subtype.details.flags | 256 /* FunctionTypeFlags.Overloaded */);
+            subtype = types_1.FunctionType.cloneWithNewFlags(subtype, subtype.shared.flags | 256 /* FunctionTypeFlags.Overloaded */);
             filteredOverloads.push(subtype);
         });
         if (filteredOverloads.length === 1) {
@@ -3485,7 +3582,8 @@ class ApplySolvedTypeVarsTransformer extends TypeVarTransformer {
         }
         return types_1.OverloadedFunctionType.create(filteredOverloads);
     }
-    _solveDefaultType(defaultType, recursionCount) {
+    _solveDefaultType(typeVar, recursionCount) {
+        const defaultType = typeVar.shared.defaultType;
         const wasSolvingDefaultType = this._isSolvingDefaultType;
         this._isSolvingDefaultType = true;
         const result = this.apply(defaultType, recursionCount);
@@ -3503,7 +3601,7 @@ class ExpectedTypeTransformer extends TypeVarTransformer {
         if (!this._isTypeVarLive(typeVar)) {
             return types_1.TypeVarType.cloneAsInScopePlaceholder(typeVar, this._usageOffset);
         }
-        return typeVar;
+        return undefined;
     }
     transformParamSpec(paramSpec) {
         if (!this._isTypeVarLive(paramSpec)) {
@@ -3512,7 +3610,7 @@ class ExpectedTypeTransformer extends TypeVarTransformer {
         return undefined;
     }
     _isTypeVarLive(typeVar) {
-        return this._liveTypeVarScopes.some((scopeId) => typeVar.scopeId === scopeId);
+        return this._liveTypeVarScopes.some((scopeId) => { var _a; return typeVar.priv.scopeId === scopeId || ((_a = typeVar.priv.externalTypeVar) === null || _a === void 0 ? void 0 : _a.priv.scopeId) === scopeId; });
     }
 }
 class InScopePlaceholderTransformer extends TypeVarTransformer {
@@ -3522,13 +3620,13 @@ class InScopePlaceholderTransformer extends TypeVarTransformer {
     }
     transformTypeVar(typeVar) {
         var _a;
-        if (typeVar.isInScopePlaceholder) {
+        if (typeVar.priv.isInScopePlaceholder) {
             return (_a = this._signatureContext.getTypeVarType(typeVar)) !== null && _a !== void 0 ? _a : typeVar;
         }
-        return typeVar;
+        return undefined;
     }
     transformParamSpec(paramSpec) {
-        if (paramSpec.isInScopePlaceholder) {
+        if (paramSpec.priv.isInScopePlaceholder) {
             return this._signatureContext.getParamSpecType(paramSpec);
         }
         return undefined;
@@ -3537,7 +3635,7 @@ class InScopePlaceholderTransformer extends TypeVarTransformer {
 function applyInScopePlaceholdersToType(type, signatureContext) {
     // Handle the common case where there are no in-scope placeholders.
     // No more work is required in this case.
-    if (!signatureContext.getTypeVars().some((entry) => entry.typeVar.isInScopePlaceholder)) {
+    if (!signatureContext.getTypeVars().some((entry) => entry.typeVar.priv.isInScopePlaceholder)) {
         return type;
     }
     const transformer = new InScopePlaceholderTransformer(signatureContext);