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

package/dist/analyzer/types.js

@@ -8,7 +8,8 @@
  * Representation of types used during type analysis within Python.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isSameWithoutLiteralValue = exports.combineTypes = exports.findSubtype = exports.removeFromUnion = exports.removeUnbound = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isParamSpec = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedVariadicTypeVar = exports.isVariadicTypeVar = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNever = exports.TypeVarType = exports.TypeVarScopeType = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedFunctionType = exports.FunctionType = exports.FunctionTypeFlags = exports.isKeywordOnlySeparator = exports.isPositionOnlySeparator = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.InScopePlaceholderScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
+exports.findSubtype = exports.removeFromUnion = exports.removeUnbound = exports.removeUnknownFromUnion = exports.isTypeSame = exports.getTypeAliasInfo = exports.isOverloadedFunction = exports.isFunction = exports.isParamSpec = exports.isUnpacked = exports.isUnpackedClass = exports.isUnpackedVariadicTypeVar = exports.isVariadicTypeVar = exports.isTypeVar = exports.isModule = exports.isClassInstance = exports.isInstantiableClass = exports.isClass = exports.isPossiblyUnbound = exports.isUnion = exports.isUnbound = exports.isAnyOrUnknown = exports.isUnknown = exports.isAny = exports.isNever = exports.TypeVarType = exports.TypeVarScopeType = exports.Variance = exports.UnionType = exports.TypeCondition = exports.AnyType = exports.NeverType = exports.OverloadedFunctionType = exports.FunctionType = exports.FunctionTypeFlags = exports.isKeywordOnlySeparator = exports.isPositionOnlySeparator = exports.FunctionParam = exports.FunctionParamFlags = exports.ClassType = exports.ClassTypeFlags = exports.ModuleType = exports.UnknownType = exports.UnboundType = exports.TypeBase = exports.maxTypeRecursionCount = exports.EnumLiteral = exports.InScopePlaceholderScopeId = exports.TypeFlags = exports.TypeCategory = void 0;
+exports.isSameWithoutLiteralValue = exports.combineTypes = void 0;
 const debug_1 = require("../common/debug");
 var TypeCategory;
 (function (TypeCategory) {
@@ -46,6 +47,12 @@ var TypeFlags;
     TypeFlags[TypeFlags["Instantiable"] = 1] = "Instantiable";
     // This type refers to something that has been instantiated.
     TypeFlags[TypeFlags["Instance"] = 2] = "Instance";
+    // This type is inferred within a py.typed source file and could be
+    // inferred differently by other type checkers.
+    TypeFlags[TypeFlags["Ambiguous"] = 4] = "Ambiguous";
+    // This mask indicates which flags should be considered significant
+    // when comparing two types for equivalence.
+    TypeFlags[TypeFlags["TypeCompatibilityMask"] = 3] = "TypeCompatibilityMask";
 })(TypeFlags || (exports.TypeFlags = TypeFlags = {}));
 exports.InScopePlaceholderScopeId = '-';
 class EnumLiteral {
@@ -79,42 +86,69 @@ var TypeBase;
     }
     TypeBase.isInstance = isInstance;
     function isAmbiguous(type) {
-        return !!type.isAmbiguous;
+        return (type.flags & 4 /* TypeFlags.Ambiguous */) !== 0;
     }
     TypeBase.isAmbiguous = isAmbiguous;
+    function addProps(type) {
+        if (!type.props) {
+            type.props = {
+                instantiableDepth: undefined,
+                specialForm: undefined,
+                typeAliasInfo: undefined,
+                condition: undefined,
+            };
+        }
+        return type.props;
+    }
+    TypeBase.addProps = addProps;
+    function setSpecialForm(type, specialForm) {
+        TypeBase.addProps(type).specialForm = specialForm;
+    }
+    TypeBase.setSpecialForm = setSpecialForm;
+    function setInstantiableDepth(type, depth) {
+        TypeBase.addProps(type).instantiableDepth = depth;
+    }
+    TypeBase.setInstantiableDepth = setInstantiableDepth;
+    function setTypeAliasInfo(type, typeAliasInfo) {
+        TypeBase.addProps(type).typeAliasInfo = typeAliasInfo;
+    }
+    TypeBase.setTypeAliasInfo = setTypeAliasInfo;
+    function setCondition(type, condition) {
+        TypeBase.addProps(type).condition = condition;
+    }
+    TypeBase.setCondition = setCondition;
     function cloneType(type) {
         const clone = { ...type };
-        delete clone.cached;
+        if (type.props) {
+            clone.props = { ...type.props };
+        }
+        if (type.priv) {
+            clone.priv = { ...type.priv };
+        }
+        clone.cached = undefined;
         return clone;
     }
     TypeBase.cloneType = cloneType;
     function cloneAsSpecialForm(type, specialForm) {
-        const clone = { ...type };
-        delete clone.cached;
-        if (specialForm) {
-            clone.specialForm = specialForm;
-        }
-        else {
-            delete clone.specialForm;
-        }
+        const clone = TypeBase.cloneType(type);
+        TypeBase.setSpecialForm(clone, specialForm);
         return clone;
     }
     TypeBase.cloneAsSpecialForm = cloneAsSpecialForm;
     function cloneTypeAsInstance(type, cache) {
+        var _a;
         (0, debug_1.assert)(TypeBase.isInstantiable(type));
         const newInstance = TypeBase.cloneType(type);
-        if (newInstance.instantiableNestingLevel === undefined) {
+        const depth = (_a = newInstance.props) === null || _a === void 0 ? void 0 : _a.instantiableDepth;
+        if (depth === undefined) {
             newInstance.flags &= ~1 /* TypeFlags.Instantiable */;
             newInstance.flags |= 2 /* TypeFlags.Instance */;
-            delete newInstance.instantiableNestingLevel;
+        }
+        else if (depth <= 1) {
+            TypeBase.setInstantiableDepth(newInstance, undefined);
         }
         else {
-            if (newInstance.instantiableNestingLevel === 1) {
-                delete newInstance.instantiableNestingLevel;
-            }
-            else {
-                newInstance.instantiableNestingLevel--;
-            }
+            TypeBase.setInstantiableDepth(newInstance, depth - 1);
         }
         // Should we cache it for next time?
         if (cache) {
@@ -127,18 +161,21 @@ var TypeBase;
     }
     TypeBase.cloneTypeAsInstance = cloneTypeAsInstance;
     function cloneTypeAsInstantiable(type, cache) {
+        var _a, _b;
         const newInstance = TypeBase.cloneType(type);
         if (TypeBase.isInstance(type)) {
             newInstance.flags &= ~2 /* TypeFlags.Instance */;
             newInstance.flags |= 1 /* TypeFlags.Instantiable */;
         }
         else {
-            newInstance.instantiableNestingLevel =
-                newInstance.instantiableNestingLevel === undefined ? 1 : newInstance.instantiableNestingLevel;
+            const oldDepth = (_a = type.props) === null || _a === void 0 ? void 0 : _a.instantiableDepth;
+            TypeBase.setInstantiableDepth(newInstance, oldDepth === undefined ? 1 : oldDepth + 1);
         }
         // Remove type alias information because the type will no longer match
         // that of the type alias definition.
-        delete newInstance.typeAliasInfo;
+        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo) {
+            TypeBase.setTypeAliasInfo(newInstance, undefined);
+        }
         // Should we cache it for next time?
         if (cache) {
             if (!type.cached) {
@@ -151,36 +188,38 @@ var TypeBase;
     TypeBase.cloneTypeAsInstantiable = cloneTypeAsInstantiable;
     function cloneForTypeAlias(type, name, fullName, moduleName, fileUri, typeVarScopeId, isPep695Syntax, typeParams, typeArgs) {
         const typeClone = cloneType(type);
-        typeClone.typeAliasInfo = {
+        TypeBase.setTypeAliasInfo(typeClone, {
             name,
             fullName,
             moduleName,
             fileUri,
-            typeParameters: typeParams,
-            typeArguments: typeArgs,
             typeVarScopeId,
             isPep695Syntax,
-        };
+            typeParameters: typeParams,
+            usageVariance: undefined,
+            typeArguments: typeArgs,
+        });
         return typeClone;
     }
     TypeBase.cloneForTypeAlias = cloneForTypeAlias;
     function cloneForCondition(type, condition) {
+        var _a;
         // Handle the common case where there are no conditions. In this case,
         // cloning isn't necessary.
-        if (type.condition === undefined && condition === undefined) {
+        if (((_a = type.props) === null || _a === void 0 ? void 0 : _a.condition) === undefined && condition === undefined) {
             return type;
         }
         const typeClone = cloneType(type);
-        typeClone.condition = condition;
+        TypeBase.setCondition(typeClone, condition);
         return typeClone;
     }
     TypeBase.cloneForCondition = cloneForCondition;
     function cloneForAmbiguousType(type) {
-        if (type.isAmbiguous) {
+        if (TypeBase.isAmbiguous(type)) {
             return type;
         }
         const typeClone = cloneType(type);
-        typeClone.isAmbiguous = true;
+        typeClone.flags |= 4 /* TypeFlags.Ambiguous */;
         return typeClone;
     }
     TypeBase.cloneForAmbiguousType = cloneForAmbiguousType;
@@ -190,6 +229,10 @@ var UnboundType;
     const _instance = {
         category: 0 /* TypeCategory.Unbound */,
         flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: undefined,
     };
     function create() {
         // All Unbound objects are the same, so use a shared instance.
@@ -197,8 +240,9 @@ var UnboundType;
     }
     UnboundType.create = create;
     function convertToInstance(type) {
+        var _a;
         // Remove the "special form" if present. Otherwise return the existing type.
-        return type.specialForm ? UnboundType.create() : type;
+        return ((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) ? UnboundType.create() : type;
     }
     UnboundType.convertToInstance = convertToInstance;
 })(UnboundType || (exports.UnboundType = UnboundType = {}));
@@ -207,12 +251,24 @@ var UnknownType;
     const _instance = {
         category: 1 /* TypeCategory.Unknown */,
         flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
-        isIncomplete: false,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: {
+            isIncomplete: false,
+            possibleType: undefined,
+        },
     };
     const _incompleteInstance = {
         category: 1 /* TypeCategory.Unknown */,
         flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
-        isIncomplete: true,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: {
+            isIncomplete: true,
+            possibleType: undefined,
+        },
     };
     function create(isIncomplete = false) {
         return isIncomplete ? _incompleteInstance : _instance;
@@ -222,15 +278,21 @@ var UnknownType;
         const unknownWithPossibleType = {
             category: 1 /* TypeCategory.Unknown */,
             flags: 1 /* TypeFlags.Instantiable */ | 2 /* TypeFlags.Instance */,
-            isIncomplete,
-            possibleType,
+            props: undefined,
+            cached: undefined,
+            shared: undefined,
+            priv: {
+                isIncomplete,
+                possibleType,
+            },
         };
         return unknownWithPossibleType;
     }
     UnknownType.createPossibleType = createPossibleType;
     function convertToInstance(type) {
+        var _a;
         // Remove the "special form" if present. Otherwise return the existing type.
-        return type.specialForm ? UnknownType.create(type.isIncomplete) : type;
+        return ((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) ? UnknownType.create(type.priv.isIncomplete) : type;
     }
     UnknownType.convertToInstance = convertToInstance;
 })(UnknownType || (exports.UnknownType = UnknownType = {}));
@@ -239,11 +301,18 @@ var ModuleType;
     function create(moduleName, fileUri, symbolTable) {
         const newModuleType = {
             category: 7 /* TypeCategory.Module */,
-            fields: symbolTable || new Map(),
-            loaderFields: new Map(),
             flags: 1 /* TypeFlags.Instantiable */ | 1 /* TypeFlags.Instantiable */,
-            moduleName,
-            fileUri,
+            props: undefined,
+            cached: undefined,
+            shared: undefined,
+            priv: {
+                fields: symbolTable || new Map(),
+                docString: undefined,
+                notPresentFieldType: undefined,
+                loaderFields: new Map(),
+                moduleName,
+                fileUri,
+            },
         };
         return newModuleType;
     }
@@ -252,16 +321,16 @@ var ModuleType;
         // Always look for the symbol in the module's fields before consulting
         // the loader fields. The loader runs before the module, so its values
         // will be overwritten by the module.
-        let symbol = moduleType.fields.get(name);
-        if (moduleType.loaderFields) {
+        let symbol = moduleType.priv.fields.get(name);
+        if (moduleType.priv.loaderFields) {
             if (!symbol) {
-                symbol = moduleType.loaderFields.get(name);
+                symbol = moduleType.priv.loaderFields.get(name);
             }
             else if (symbol.getDeclarations().length === 1) {
                 // If the symbol is hidden when accessed via the module but is
                 // also accessible through a loader field, use the latter so it
                 // isn't flagged as an error.
-                const loaderSymbol = moduleType.loaderFields.get(name);
+                const loaderSymbol = moduleType.priv.loaderFields.get(name);
                 if (loaderSymbol && !loaderSymbol.isExternallyHidden()) {
                     symbol = loaderSymbol;
                 }
@@ -275,7 +344,7 @@ var ClassTypeFlags;
 (function (ClassTypeFlags) {
     ClassTypeFlags[ClassTypeFlags["None"] = 0] = "None";
     // Class is defined in the "builtins" or "typing" file.
-    ClassTypeFlags[ClassTypeFlags["BuiltInClass"] = 1] = "BuiltInClass";
+    ClassTypeFlags[ClassTypeFlags["BuiltIn"] = 1] = "BuiltIn";
     // Class requires special-case handling because it
     // exhibits non-standard behavior or is not defined
     // formally as a class. Examples include 'Optional'
@@ -358,7 +427,10 @@ var ClassType;
     function createInstantiable(name, fullName, moduleName, fileUri, flags, typeSourceId, declaredMetaclass, effectiveMetaclass, docString) {
         const newClass = {
             category: 6 /* TypeCategory.Class */,
-            details: {
+            flags: 1 /* TypeFlags.Instantiable */,
+            props: undefined,
+            cached: undefined,
+            shared: {
                 name,
                 fullName,
                 moduleName,
@@ -373,13 +445,13 @@ var ClassType;
                 typeParameters: [],
                 docString,
             },
-            flags: 1 /* TypeFlags.Instantiable */,
+            priv: {},
         };
         return newClass;
     }
     ClassType.createInstantiable = createInstantiable;
     function cloneAsInstance(type, includeSubclasses = true) {
-        var _a;
+        var _a, _b;
         if (TypeBase.isInstance(type)) {
             return type;
         }
@@ -387,9 +459,11 @@ var ClassType;
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ includeSubclasses);
-        delete newInstance.specialForm;
+        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+            TypeBase.setSpecialForm(newInstance, undefined);
+        }
         if (includeSubclasses) {
-            newInstance.includeSubclasses = true;
+            newInstance.priv.includeSubclasses = true;
         }
         return newInstance;
     }
@@ -401,131 +475,136 @@ var ClassType;
         }
         const newInstance = TypeBase.cloneTypeAsInstantiable(type, includeSubclasses);
         if (includeSubclasses) {
-            newInstance.includeSubclasses = true;
+            newInstance.priv.includeSubclasses = true;
         }
         return newInstance;
     }
     ClassType.cloneAsInstantiable = cloneAsInstantiable;
     function cloneForSpecialization(classType, typeArguments, isTypeArgumentExplicit, includeSubclasses = false, tupleTypeArguments, isEmptyContainer) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.typeArguments = (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 0 ? undefined : typeArguments;
-        newClassType.isTypeArgumentExplicit = isTypeArgumentExplicit;
+        newClassType.priv.typeArguments = (typeArguments === null || typeArguments === void 0 ? void 0 : typeArguments.length) === 0 ? undefined : typeArguments;
+        newClassType.priv.isTypeArgumentExplicit = isTypeArgumentExplicit;
         if (includeSubclasses) {
-            newClassType.includeSubclasses = true;
+            newClassType.priv.includeSubclasses = true;
         }
-        newClassType.tupleTypeArguments = tupleTypeArguments ? [...tupleTypeArguments] : undefined;
+        newClassType.priv.tupleTypeArguments = tupleTypeArguments ? [...tupleTypeArguments] : undefined;
         if (isEmptyContainer !== undefined) {
-            newClassType.isEmptyContainer = isEmptyContainer;
+            newClassType.priv.isEmptyContainer = isEmptyContainer;
         }
         return newClassType;
     }
     ClassType.cloneForSpecialization = cloneForSpecialization;
     function cloneIncludeSubclasses(classType, includeSubclasses = true) {
-        if (!!classType.includeSubclasses === includeSubclasses) {
+        if (!!classType.priv.includeSubclasses === includeSubclasses) {
             return classType;
         }
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.includeSubclasses = includeSubclasses;
+        newClassType.priv.includeSubclasses = includeSubclasses;
         return newClassType;
     }
     ClassType.cloneIncludeSubclasses = cloneIncludeSubclasses;
     function cloneWithLiteral(classType, value) {
+        var _a;
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.literalValue = value;
+        newClassType.priv.literalValue = value;
         // Remove type alias information because the type will no longer match
         // that of the type alias definition if we change the literal type.
-        delete newClassType.typeAliasInfo;
+        if ((_a = newClassType.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+            TypeBase.setTypeAliasInfo(newClassType, undefined);
+        }
         return newClassType;
     }
     ClassType.cloneWithLiteral = cloneWithLiteral;
     function cloneForDeprecatedInstance(type, deprecatedMessage) {
         const newClassType = TypeBase.cloneType(type);
-        newClassType.deprecatedInstanceMessage = deprecatedMessage;
+        newClassType.priv.deprecatedInstanceMessage = deprecatedMessage;
         return newClassType;
     }
     ClassType.cloneForDeprecatedInstance = cloneForDeprecatedInstance;
     function cloneForTypingAlias(classType, aliasName) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.aliasName = aliasName;
+        newClassType.priv.aliasName = aliasName;
         return newClassType;
     }
     ClassType.cloneForTypingAlias = cloneForTypingAlias;
     function cloneForNarrowedTypedDictEntries(classType, narrowedEntries) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.typedDictNarrowedEntries = narrowedEntries;
+        newClassType.priv.typedDictNarrowedEntries = narrowedEntries;
         return newClassType;
     }
     ClassType.cloneForNarrowedTypedDictEntries = cloneForNarrowedTypedDictEntries;
     function cloneForPartialTypedDict(classType) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.isTypedDictPartial = true;
+        newClassType.priv.isTypedDictPartial = true;
         return newClassType;
     }
     ClassType.cloneForPartialTypedDict = cloneForPartialTypedDict;
     function cloneRemoveTypePromotions(classType) {
-        if (!classType.includePromotions) {
+        if (!classType.priv.includePromotions) {
             return classType;
         }
         const newClassType = TypeBase.cloneType(classType);
-        delete newClassType.includePromotions;
+        if (newClassType.priv.includePromotions !== undefined) {
+            newClassType.priv.includePromotions = undefined;
+        }
         return newClassType;
     }
     ClassType.cloneRemoveTypePromotions = cloneRemoveTypePromotions;
     function cloneForTypeGuard(classType, typeGuardType, isStrictTypeGuard) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.typeGuardType = typeGuardType;
-        newClassType.isStrictTypeGuard = isStrictTypeGuard;
+        newClassType.priv.typeGuardType = typeGuardType;
+        newClassType.priv.isStrictTypeGuard = isStrictTypeGuard;
         return newClassType;
     }
     ClassType.cloneForTypeGuard = cloneForTypeGuard;
     function cloneForSymbolTableUpdate(classType) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.details = { ...newClassType.details };
-        newClassType.details.fields = new Map(newClassType.details.fields);
-        newClassType.details.mro = Array.from(newClassType.details.mro);
-        newClassType.details.mro[0] = cloneAsInstantiable(newClassType);
+        newClassType.shared = { ...newClassType.shared };
+        newClassType.shared.fields = new Map(newClassType.shared.fields);
+        newClassType.shared.mro = Array.from(newClassType.shared.mro);
+        newClassType.shared.mro[0] = cloneAsInstantiable(newClassType);
         return newClassType;
     }
     ClassType.cloneForSymbolTableUpdate = cloneForSymbolTableUpdate;
     function cloneForUnpacked(classType, isUnpacked = true) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.isUnpacked = isUnpacked;
+        newClassType.priv.isUnpacked = isUnpacked;
         return newClassType;
     }
     ClassType.cloneForUnpacked = cloneForUnpacked;
     function cloneWithNewFlags(classType, newFlags) {
         const newClassType = TypeBase.cloneType(classType);
-        newClassType.details = { ...newClassType.details };
-        newClassType.details.flags = newFlags;
+        newClassType.shared = { ...newClassType.shared };
+        newClassType.shared.flags = newFlags;
         return newClassType;
     }
     ClassType.cloneWithNewFlags = cloneWithNewFlags;
     function isLiteralValueSame(type1, type2) {
-        if (type1.literalValue === undefined) {
-            return type2.literalValue === undefined;
+        if (type1.priv.literalValue === undefined) {
+            return type2.priv.literalValue === undefined;
         }
-        else if (type2.literalValue === undefined) {
+        else if (type2.priv.literalValue === undefined) {
             return false;
         }
-        if (type1.literalValue instanceof EnumLiteral) {
-            if (type2.literalValue instanceof EnumLiteral) {
-                return type1.literalValue.itemName === type2.literalValue.itemName;
+        if (type1.priv.literalValue instanceof EnumLiteral) {
+            if (type2.priv.literalValue instanceof EnumLiteral) {
+                return type1.priv.literalValue.itemName === type2.priv.literalValue.itemName;
             }
             return false;
         }
-        return type1.literalValue === type2.literalValue;
+        return type1.priv.literalValue === type2.priv.literalValue;
     }
     ClassType.isLiteralValueSame = isLiteralValueSame;
     // Determines whether two typed dict classes are equivalent given
     // that one or both have narrowed entries (i.e. entries that are
     // guaranteed to be present).
     function isTypedDictNarrowedEntriesSame(type1, type2) {
-        if (type1.typedDictNarrowedEntries) {
-            if (!type2.typedDictNarrowedEntries) {
+        if (type1.priv.typedDictNarrowedEntries) {
+            if (!type2.priv.typedDictNarrowedEntries) {
                 return false;
             }
-            const tdEntries1 = type1.typedDictNarrowedEntries;
-            const tdEntries2 = type2.typedDictNarrowedEntries;
+            const tdEntries1 = type1.priv.typedDictNarrowedEntries;
+            const tdEntries2 = type2.priv.typedDictNarrowedEntries;
             if (tdEntries1.size !== tdEntries2.size) {
                 return false;
             }
@@ -541,7 +620,7 @@ var ClassType;
                 }
             }
         }
-        else if (type2.typedDictNarrowedEntries) {
+        else if (type2.priv.typedDictNarrowedEntries) {
             return false;
         }
         return true;
@@ -552,11 +631,11 @@ var ClassType;
     // within type1.
     function isTypedDictNarrower(type1, type2) {
         var _a;
-        const tdEntries2 = type2.typedDictNarrowedEntries;
+        const tdEntries2 = type2.priv.typedDictNarrowedEntries;
         if (!tdEntries2) {
             return true;
         }
-        const tdEntries1 = (_a = type1.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : new Map();
+        const tdEntries1 = (_a = type1.priv.typedDictNarrowedEntries) !== null && _a !== void 0 ? _a : new Map();
         let key;
         let entry2;
         for ([key, entry2] of tdEntries2.entries()) {
@@ -572,189 +651,189 @@ var ClassType;
     ClassType.isTypedDictNarrower = isTypedDictNarrower;
     // Is the class generic but not specialized?
     function isUnspecialized(classType) {
-        return classType.details.typeParameters.length > 0 && classType.typeArguments === undefined;
+        return classType.shared.typeParameters.length > 0 && classType.priv.typeArguments === undefined;
     }
     ClassType.isUnspecialized = isUnspecialized;
     function isSpecialBuiltIn(classType, className) {
-        if (!(classType.details.flags & 2 /* ClassTypeFlags.SpecialBuiltIn */) && !classType.aliasName) {
+        if (!(classType.shared.flags & 2 /* ClassTypeFlags.SpecialBuiltIn */) && !classType.priv.aliasName) {
             return false;
         }
         if (className !== undefined) {
-            return classType.details.name === className;
+            return classType.shared.name === className;
         }
         return true;
     }
     ClassType.isSpecialBuiltIn = isSpecialBuiltIn;
     function isBuiltIn(classType, className) {
-        if (!(classType.details.flags & 1 /* ClassTypeFlags.BuiltInClass */)) {
+        if (!(classType.shared.flags & 1 /* ClassTypeFlags.BuiltIn */)) {
             return false;
         }
         if (className !== undefined) {
             const classArray = Array.isArray(className) ? className : [className];
-            return (classArray.some((name) => name === classType.details.name) ||
-                classArray.some((name) => name === classType.aliasName));
+            return (classArray.some((name) => name === classType.shared.name) ||
+                classArray.some((name) => name === classType.priv.aliasName));
         }
         return true;
     }
     ClassType.isBuiltIn = isBuiltIn;
     function supportsAbstractMethods(classType) {
-        return !!(classType.details.flags & 64 /* ClassTypeFlags.SupportsAbstractMethods */);
+        return !!(classType.shared.flags & 64 /* ClassTypeFlags.SupportsAbstractMethods */);
     }
     ClassType.supportsAbstractMethods = supportsAbstractMethods;
     function isDataClass(classType) {
-        return !!classType.details.dataClassBehaviors;
+        return !!classType.shared.dataClassBehaviors;
     }
     ClassType.isDataClass = isDataClass;
     function isDataClassSkipGenerateInit(classType) {
         var _a;
-        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateInit);
+        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateInit);
     }
     ClassType.isDataClassSkipGenerateInit = isDataClassSkipGenerateInit;
     function isDataClassSkipGenerateEq(classType) {
         var _a;
-        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateEq);
+        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.skipGenerateEq);
     }
     ClassType.isDataClassSkipGenerateEq = isDataClassSkipGenerateEq;
     function isDataClassFrozen(classType) {
         var _a;
-        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.frozen);
+        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.frozen);
     }
     ClassType.isDataClassFrozen = isDataClassFrozen;
     function isDataClassGenerateOrder(classType) {
         var _a;
-        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateOrder);
+        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateOrder);
     }
     ClassType.isDataClassGenerateOrder = isDataClassGenerateOrder;
     function isDataClassKeywordOnly(classType) {
         var _a;
-        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.keywordOnly);
+        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.keywordOnly);
     }
     ClassType.isDataClassKeywordOnly = isDataClassKeywordOnly;
     function isDataClassGenerateSlots(classType) {
         var _a;
-        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateSlots);
+        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateSlots);
     }
     ClassType.isDataClassGenerateSlots = isDataClassGenerateSlots;
     function isDataClassGenerateHash(classType) {
         var _a;
-        return !!((_a = classType.details.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateHash);
+        return !!((_a = classType.shared.dataClassBehaviors) === null || _a === void 0 ? void 0 : _a.generateHash);
     }
     ClassType.isDataClassGenerateHash = isDataClassGenerateHash;
     function isTypeCheckOnly(classType) {
-        return !!(classType.details.flags & 1048576 /* ClassTypeFlags.TypeCheckOnly */);
+        return !!(classType.shared.flags & 1048576 /* ClassTypeFlags.TypeCheckOnly */);
     }
     ClassType.isTypeCheckOnly = isTypeCheckOnly;
     function isNewTypeClass(classType) {
-        return !!(classType.details.flags & 2097152 /* ClassTypeFlags.NewTypeClass */);
+        return !!(classType.shared.flags & 2097152 /* ClassTypeFlags.NewTypeClass */);
     }
     ClassType.isNewTypeClass = isNewTypeClass;
     function isValidTypeAliasClass(classType) {
-        return !!(classType.details.flags & 4194304 /* ClassTypeFlags.ValidTypeAliasClass */);
+        return !!(classType.shared.flags & 4194304 /* ClassTypeFlags.ValidTypeAliasClass */);
     }
     ClassType.isValidTypeAliasClass = isValidTypeAliasClass;
     function isSpecialFormClass(classType) {
-        return !!(classType.details.flags & 8388608 /* ClassTypeFlags.SpecialFormClass */);
+        return !!(classType.shared.flags & 8388608 /* ClassTypeFlags.SpecialFormClass */);
     }
     ClassType.isSpecialFormClass = isSpecialFormClass;
     function isIllegalIsinstanceClass(classType) {
-        return !!(classType.details.flags & 16777216 /* ClassTypeFlags.IllegalIsinstanceClass */);
+        return !!(classType.shared.flags & 16777216 /* ClassTypeFlags.IllegalIsinstanceClass */);
     }
     ClassType.isIllegalIsinstanceClass = isIllegalIsinstanceClass;
     function isTypedDictClass(classType) {
-        return !!(classType.details.flags & 4 /* ClassTypeFlags.TypedDictClass */);
+        return !!(classType.shared.flags & 4 /* ClassTypeFlags.TypedDictClass */);
     }
     ClassType.isTypedDictClass = isTypedDictClass;
     function isCanOmitDictValues(classType) {
-        return !!(classType.details.flags & 32 /* ClassTypeFlags.CanOmitDictValues */);
+        return !!(classType.shared.flags & 32 /* ClassTypeFlags.CanOmitDictValues */);
     }
     ClassType.isCanOmitDictValues = isCanOmitDictValues;
     function isTypedDictMarkedClosed(classType) {
-        return !!(classType.details.flags & 8 /* ClassTypeFlags.TypedDictMarkedClosed */);
+        return !!(classType.shared.flags & 8 /* ClassTypeFlags.TypedDictMarkedClosed */);
     }
     ClassType.isTypedDictMarkedClosed = isTypedDictMarkedClosed;
     function isTypedDictEffectivelyClosed(classType) {
-        return !!(classType.details.flags & 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */);
+        return !!(classType.shared.flags & 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */);
     }
     ClassType.isTypedDictEffectivelyClosed = isTypedDictEffectivelyClosed;
     function isEnumClass(classType) {
-        return !!(classType.details.flags & 65536 /* ClassTypeFlags.EnumClass */);
+        return !!(classType.shared.flags & 65536 /* ClassTypeFlags.EnumClass */);
     }
     ClassType.isEnumClass = isEnumClass;
     function isPropertyClass(classType) {
-        return !!(classType.details.flags & 128 /* ClassTypeFlags.PropertyClass */);
+        return !!(classType.shared.flags & 128 /* ClassTypeFlags.PropertyClass */);
     }
     ClassType.isPropertyClass = isPropertyClass;
     function isClassProperty(classType) {
-        return !!(classType.details.flags & 131072 /* ClassTypeFlags.ClassProperty */);
+        return !!(classType.shared.flags & 131072 /* ClassTypeFlags.ClassProperty */);
     }
     ClassType.isClassProperty = isClassProperty;
     function isFinal(classType) {
-        return !!(classType.details.flags & 256 /* ClassTypeFlags.Final */);
+        return !!(classType.shared.flags & 256 /* ClassTypeFlags.Final */);
     }
     ClassType.isFinal = isFinal;
     function isProtocolClass(classType) {
-        return !!(classType.details.flags & 512 /* ClassTypeFlags.ProtocolClass */);
+        return !!(classType.shared.flags & 512 /* ClassTypeFlags.ProtocolClass */);
     }
     ClassType.isProtocolClass = isProtocolClass;
     function isDefinedInStub(classType) {
-        return !!(classType.details.flags & 262144 /* ClassTypeFlags.DefinedInStub */);
+        return !!(classType.shared.flags & 262144 /* ClassTypeFlags.DefinedInStub */);
     }
     ClassType.isDefinedInStub = isDefinedInStub;
     function isPseudoGenericClass(classType) {
-        return !!(classType.details.flags & 1024 /* ClassTypeFlags.PseudoGenericClass */);
+        return !!(classType.shared.flags & 1024 /* ClassTypeFlags.PseudoGenericClass */);
     }
     ClassType.isPseudoGenericClass = isPseudoGenericClass;
     function getDataClassEntries(classType) {
         var _a, _b;
-        (_b = (_a = classType.details).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
-        return classType.details.dataClassEntries || [];
+        (_b = (_a = classType.shared).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
+        return classType.shared.dataClassEntries || [];
     }
     ClassType.getDataClassEntries = getDataClassEntries;
     function isRuntimeCheckable(classType) {
-        return !!(classType.details.flags & 2048 /* ClassTypeFlags.RuntimeCheckable */);
+        return !!(classType.shared.flags & 2048 /* ClassTypeFlags.RuntimeCheckable */);
     }
     ClassType.isRuntimeCheckable = isRuntimeCheckable;
     function isTypingExtensionClass(classType) {
-        return !!(classType.details.flags & 4096 /* ClassTypeFlags.TypingExtensionClass */);
+        return !!(classType.shared.flags & 4096 /* ClassTypeFlags.TypingExtensionClass */);
     }
     ClassType.isTypingExtensionClass = isTypingExtensionClass;
     function isPartiallyEvaluated(classType) {
-        return !!(classType.details.flags & 8192 /* ClassTypeFlags.PartiallyEvaluated */);
+        return !!(classType.shared.flags & 8192 /* ClassTypeFlags.PartiallyEvaluated */);
     }
     ClassType.isPartiallyEvaluated = isPartiallyEvaluated;
     function hasCustomClassGetItem(classType) {
-        return !!(classType.details.flags & 16384 /* ClassTypeFlags.HasCustomClassGetItem */);
+        return !!(classType.shared.flags & 16384 /* ClassTypeFlags.HasCustomClassGetItem */);
     }
     ClassType.hasCustomClassGetItem = hasCustomClassGetItem;
     function isTupleClass(classType) {
-        return !!(classType.details.flags & 32768 /* ClassTypeFlags.TupleClass */);
+        return !!(classType.shared.flags & 32768 /* ClassTypeFlags.TupleClass */);
     }
     ClassType.isTupleClass = isTupleClass;
     function isReadOnlyInstanceVariables(classType) {
-        return !!(classType.details.flags & 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
+        return !!(classType.shared.flags & 524288 /* ClassTypeFlags.ReadOnlyInstanceVariables */);
     }
     ClassType.isReadOnlyInstanceVariables = isReadOnlyInstanceVariables;
     function getTypeParameters(classType) {
-        return classType.details.typeParameters;
+        return classType.shared.typeParameters;
     }
     ClassType.getTypeParameters = getTypeParameters;
     function derivesFromAnyOrUnknown(classType) {
-        return classType.details.mro.some((baseClass) => isAnyOrUnknown(baseClass));
+        return classType.shared.mro.some((baseClass) => isAnyOrUnknown(baseClass));
     }
     ClassType.derivesFromAnyOrUnknown = derivesFromAnyOrUnknown;
     function getSymbolTable(classType) {
         var _a, _b;
-        (_b = (_a = classType.details).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
-        return classType.details.fields;
+        (_b = (_a = classType.shared).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
+        return classType.shared.fields;
     }
     ClassType.getSymbolTable = getSymbolTable;
     function getInheritedSlotsNames(classType) {
         var _a, _b, _c, _d;
         // First synthesize methods if needed. The slots entries
         // can depend on synthesized methods.
-        (_b = (_a = classType.details).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
-        (_d = (_c = classType.details).calculateInheritedSlotsNamesDeferred) === null || _d === void 0 ? void 0 : _d.call(_c);
-        return classType.details.inheritedSlotsNamesCached;
+        (_b = (_a = classType.shared).synthesizeMethodsDeferred) === null || _b === void 0 ? void 0 : _b.call(_a);
+        (_d = (_c = classType.shared).calculateInheritedSlotsNamesDeferred) === null || _d === void 0 ? void 0 : _d.call(_c);
+        return classType.shared.inheritedSlotsNamesCached;
     }
     ClassType.getInheritedSlotsNames = getInheritedSlotsNames;
     // Similar to isPartiallyEvaluated except that it also looks at all of the
@@ -762,16 +841,16 @@ var ClassType;
     // partially evaluated.
     function isHierarchyPartiallyEvaluated(classType) {
         return (ClassType.isPartiallyEvaluated(classType) ||
-            classType.details.mro.some((mroClass) => isClass(mroClass) && ClassType.isPartiallyEvaluated(mroClass)));
+            classType.shared.mro.some((mroClass) => isClass(mroClass) && ClassType.isPartiallyEvaluated(mroClass)));
     }
     ClassType.isHierarchyPartiallyEvaluated = isHierarchyPartiallyEvaluated;
     // Same as isTypeSame except that it doesn't compare type arguments.
     function isSameGenericClass(classType, type2, recursionCount = 0) {
-        if (!classType.isTypedDictPartial !== !type2.isTypedDictPartial) {
+        if (!classType.priv.isTypedDictPartial !== !type2.priv.isTypedDictPartial) {
             return false;
         }
-        const class1Details = classType.details;
-        const class2Details = type2.details;
+        const class1Details = classType.shared;
+        const class2Details = type2.shared;
         if (class1Details === class2Details) {
             return true;
         }
@@ -826,8 +905,8 @@ var ClassType;
         // Is it the exact same class?
         if (isSameGenericClass(subclassType, parentClassType)) {
             // Handle literal types.
-            if (parentClassType.literalValue !== undefined) {
-                if (subclassType.literalValue === undefined ||
+            if (parentClassType.priv.literalValue !== undefined) {
+                if (subclassType.priv.literalValue === undefined ||
                     !ClassType.isLiteralValueSame(parentClassType, subclassType)) {
                     return false;
                 }
@@ -855,7 +934,7 @@ var ClassType;
             }
             return true;
         }
-        for (const baseClass of subclassType.details.baseClasses) {
+        for (const baseClass of subclassType.shared.baseClasses) {
             if (isInstantiableClass(baseClass)) {
                 if (isDerivedFrom(baseClass, parentClassType, inheritanceChain)) {
                     if (inheritanceChain) {
@@ -875,10 +954,39 @@ var ClassType;
     }
     ClassType.isDerivedFrom = isDerivedFrom;
     function getReverseMro(classType) {
-        return classType.details.mro.slice(0).reverse();
+        return classType.shared.mro.slice(0).reverse();
     }
     ClassType.getReverseMro = getReverseMro;
 })(ClassType || (exports.ClassType = ClassType = {}));
+var FunctionParamFlags;
+(function (FunctionParamFlags) {
+    FunctionParamFlags[FunctionParamFlags["None"] = 0] = "None";
+    // Is the name of the parameter synthesize internally?
+    FunctionParamFlags[FunctionParamFlags["NameSynthesized"] = 1] = "NameSynthesized";
+    // Does the parameter have an explicitly-declared type?
+    FunctionParamFlags[FunctionParamFlags["TypeDeclared"] = 2] = "TypeDeclared";
+    // Is the type of the parameter inferred?
+    FunctionParamFlags[FunctionParamFlags["TypeInferred"] = 4] = "TypeInferred";
+})(FunctionParamFlags || (exports.FunctionParamFlags = FunctionParamFlags = {}));
+var FunctionParam;
+(function (FunctionParam) {
+    function create(category, type, flags = FunctionParamFlags.None, name, defaultType) {
+        return { category, type, flags, name, defaultType };
+    }
+    FunctionParam.create = create;
+    function isNameSynthesized(param) {
+        return !!(param.flags & FunctionParamFlags.NameSynthesized);
+    }
+    FunctionParam.isNameSynthesized = isNameSynthesized;
+    function isTypeDeclared(param) {
+        return !!(param.flags & FunctionParamFlags.TypeDeclared);
+    }
+    FunctionParam.isTypeDeclared = isTypeDeclared;
+    function isTypeInferred(param) {
+        return !!(param.flags & FunctionParamFlags.TypeInferred);
+    }
+    FunctionParam.isTypeInferred = isTypeInferred;
+})(FunctionParam || (exports.FunctionParam = FunctionParam = {}));
 function isPositionOnlySeparator(param) {
     // A simple parameter with no name is treated as a "/" separator.
     return param.category === 0 /* ParameterCategory.Simple */ && !param.name;
@@ -942,6 +1050,8 @@ var FunctionTypeFlags;
     FunctionTypeFlags[FunctionTypeFlags["Overridden"] = 262144] = "Overridden";
     // Decorated with @no_type_check.
     FunctionTypeFlags[FunctionTypeFlags["NoTypeCheck"] = 524288] = "NoTypeCheck";
+    // Function defined in one of the core stdlib modules.
+    FunctionTypeFlags[FunctionTypeFlags["BuiltIn"] = 1048576] = "BuiltIn";
 })(FunctionTypeFlags || (exports.FunctionTypeFlags = FunctionTypeFlags = {}));
 var FunctionType;
 (function (FunctionType) {
@@ -960,37 +1070,48 @@ var FunctionType;
     function create(name, fullName, moduleName, functionFlags, typeFlags, docString) {
         const newFunctionType = {
             category: 4 /* TypeCategory.Function */,
-            details: {
+            flags: typeFlags,
+            props: undefined,
+            cached: undefined,
+            shared: {
                 name,
                 fullName,
                 moduleName,
                 flags: functionFlags,
-                parameters: [],
                 typeParameters: [],
+                parameters: [],
+                declaredReturnType: undefined,
+                declaration: undefined,
+                typeVarScopeId: undefined,
                 docString,
+                deprecatedMessage: undefined,
+                methodClass: undefined,
+                decoratorDataClassBehaviors: undefined,
             },
-            flags: typeFlags,
+            priv: {},
         };
         return newFunctionType;
     }
     // Creates a deep copy of the function type, including a fresh
     // version of _functionDetails.
     function clone(type, stripFirstParam = false, boundToType, boundTypeVarScopeId) {
-        var _a;
+        var _a, _b;
         const newFunction = TypeBase.cloneType(type);
-        newFunction.details = { ...type.details };
-        newFunction.preBoundFlags = newFunction.details.flags;
-        newFunction.boundToType = boundToType;
-        newFunction.boundTypeVarScopeId = boundTypeVarScopeId;
+        newFunction.shared = { ...type.shared };
+        newFunction.priv.preBoundFlags = newFunction.shared.flags;
+        newFunction.priv.boundToType = boundToType;
+        if (boundTypeVarScopeId) {
+            newFunction.priv.constructorTypeVarScopeId = boundTypeVarScopeId;
+        }
         if (stripFirstParam) {
-            if (type.details.parameters.length > 0) {
-                if (type.details.parameters[0].category === 0 /* ParameterCategory.Simple */) {
-                    if (type.details.parameters.length > 0 && !type.details.parameters[0].isTypeInferred) {
+            if (type.shared.parameters.length > 0) {
+                if (type.shared.parameters[0].category === 0 /* ParameterCategory.Simple */) {
+                    if (type.shared.parameters.length > 0 && !FunctionParam.isTypeInferred(type.shared.parameters[0])) {
                         // Stash away the effective type of the first parameter if it
                         // wasn't synthesized.
-                        newFunction.strippedFirstParamType = getEffectiveParameterType(type, 0);
+                        newFunction.priv.strippedFirstParamType = getEffectiveParameterType(type, 0);
                     }
-                    newFunction.details.parameters = type.details.parameters.slice(1);
+                    newFunction.shared.parameters = type.shared.parameters.slice(1);
                 }
             }
             else {
@@ -998,34 +1119,36 @@ var FunctionType;
             }
             // If we strip off the first parameter, this is no longer an
             // instance method or class method.
-            newFunction.details.flags &= ~(1 /* FunctionTypeFlags.ConstructorMethod */ | 2 /* FunctionTypeFlags.ClassMethod */);
-            newFunction.details.flags |= 4 /* FunctionTypeFlags.StaticMethod */;
+            newFunction.shared.flags &= ~(1 /* FunctionTypeFlags.ConstructorMethod */ | 2 /* FunctionTypeFlags.ClassMethod */);
+            newFunction.shared.flags |= 4 /* FunctionTypeFlags.StaticMethod */;
         }
-        if (type.typeAliasInfo !== undefined) {
-            newFunction.typeAliasInfo = type.typeAliasInfo;
+        if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+            TypeBase.setTypeAliasInfo(newFunction, type.props.typeAliasInfo);
         }
-        if (type.specializedTypes) {
-            newFunction.specializedTypes = {
+        if (type.priv.specializedTypes) {
+            newFunction.priv.specializedTypes = {
                 parameterTypes: stripFirstParam
-                    ? type.specializedTypes.parameterTypes.slice(1)
-                    : type.specializedTypes.parameterTypes,
+                    ? type.priv.specializedTypes.parameterTypes.slice(1)
+                    : type.priv.specializedTypes.parameterTypes,
                 parameterDefaultArgs: stripFirstParam
-                    ? (_a = type.specializedTypes.parameterDefaultArgs) === null || _a === void 0 ? void 0 : _a.slice(1)
-                    : type.specializedTypes.parameterDefaultArgs,
-                returnType: type.specializedTypes.returnType,
+                    ? (_b = type.priv.specializedTypes.parameterDefaultArgs) === null || _b === void 0 ? void 0 : _b.slice(1)
+                    : type.priv.specializedTypes.parameterDefaultArgs,
+                returnType: type.priv.specializedTypes.returnType,
             };
         }
-        newFunction.inferredReturnType = type.inferredReturnType;
+        newFunction.priv.inferredReturnType = type.priv.inferredReturnType;
         return newFunction;
     }
     FunctionType.clone = clone;
     function cloneAsInstance(type) {
-        var _a;
+        var _a, _b;
         if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType) {
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ true);
-        delete newInstance.specialForm;
+        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+            TypeBase.setSpecialForm(newInstance, undefined);
+        }
         return newInstance;
     }
     FunctionType.cloneAsInstance = cloneAsInstance;
@@ -1043,65 +1166,59 @@ var FunctionType;
     // with the object being cloned.
     function cloneForSpecialization(type, specializedTypes, specializedInferredReturnType) {
         const newFunction = TypeBase.cloneType(type);
-        (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.details.parameters.length);
+        (0, debug_1.assert)(specializedTypes.parameterTypes.length === type.shared.parameters.length);
         if (specializedTypes.parameterDefaultArgs) {
-            (0, debug_1.assert)(specializedTypes.parameterDefaultArgs.length === type.details.parameters.length);
+            (0, debug_1.assert)(specializedTypes.parameterDefaultArgs.length === type.shared.parameters.length);
         }
-        newFunction.specializedTypes = specializedTypes;
-        newFunction.inferredReturnType = specializedInferredReturnType;
+        newFunction.priv.specializedTypes = specializedTypes;
+        newFunction.priv.inferredReturnType = specializedInferredReturnType;
         return newFunction;
     }
     FunctionType.cloneForSpecialization = cloneForSpecialization;
     // Creates a new function based on the parameters of another function.
     function applyParamSpecValue(type, paramSpecValue) {
-        const hasPositionalOnly = paramSpecValue.details.parameters.some((param) => isPositionOnlySeparator(param));
+        const hasPositionalOnly = paramSpecValue.shared.parameters.some((param) => isPositionOnlySeparator(param));
         const newFunction = FunctionType.cloneRemoveParamSpecArgsKwargs(TypeBase.cloneType(type), hasPositionalOnly);
         const paramSpec = FunctionType.getParamSpecFromArgsKwargs(type);
         (0, debug_1.assert)(paramSpec !== undefined);
         // Make a shallow clone of the details.
-        newFunction.details = { ...newFunction.details };
-        newFunction.details.typeParameters = newFunction.details.typeParameters.filter((t) => !isTypeSame(t, paramSpec));
-        const prevParams = Array.from(newFunction.details.parameters);
-        newFunction.details.parameters = [
+        newFunction.shared = { ...newFunction.shared };
+        newFunction.shared.typeParameters = newFunction.shared.typeParameters.filter((t) => !isTypeSame(t, paramSpec));
+        const prevParams = Array.from(newFunction.shared.parameters);
+        newFunction.shared.parameters = [
             ...prevParams,
-            ...paramSpecValue.details.parameters.map((param) => {
-                return {
-                    category: param.category,
-                    name: param.name,
-                    hasDefault: param.hasDefault,
-                    defaultValueExpression: param.defaultValueExpression,
-                    isNameSynthesized: param.isNameSynthesized,
-                    hasDeclaredType: true,
-                    type: param.type,
-                };
+            ...paramSpecValue.shared.parameters.map((param) => {
+                return FunctionParam.create(param.category, param.type, (param.flags & FunctionParamFlags.NameSynthesized) | FunctionParamFlags.TypeDeclared, param.name, param.defaultType);
             }),
         ];
-        if (newFunction.details.docString === undefined) {
-            newFunction.details.docString = paramSpecValue.details.docString;
+        if (newFunction.shared.docString === undefined) {
+            newFunction.shared.docString = paramSpecValue.shared.docString;
         }
-        if (newFunction.details.deprecatedMessage === undefined) {
-            newFunction.details.deprecatedMessage = paramSpecValue.details.deprecatedMessage;
+        if (newFunction.shared.deprecatedMessage === undefined) {
+            newFunction.shared.deprecatedMessage = paramSpecValue.shared.deprecatedMessage;
         }
         const origFlagsMask = 256 /* FunctionTypeFlags.Overloaded */ | 65536 /* FunctionTypeFlags.ParamSpecValue */;
-        newFunction.details.flags = type.details.flags & origFlagsMask;
+        newFunction.shared.flags = type.shared.flags & origFlagsMask;
         const methodFlagsMask = 2 /* FunctionTypeFlags.ClassMethod */ | 4 /* FunctionTypeFlags.StaticMethod */ | 1 /* FunctionTypeFlags.ConstructorMethod */;
         // If the original function was a method, use its method type. Otherwise
         // use the method type of the param spec.
-        if (type.details.methodClass) {
-            newFunction.details.flags |= type.details.flags & methodFlagsMask;
+        if (type.shared.methodClass) {
+            newFunction.shared.flags |= type.shared.flags & methodFlagsMask;
         }
         else {
-            newFunction.details.flags |= paramSpecValue.details.flags & methodFlagsMask;
+            newFunction.shared.flags |= paramSpecValue.shared.flags & methodFlagsMask;
         }
         // Use the "..." flag from the param spec.
-        newFunction.details.flags |= paramSpecValue.details.flags & 32768 /* FunctionTypeFlags.GradualCallableForm */;
+        newFunction.shared.flags |= paramSpecValue.shared.flags & 32768 /* FunctionTypeFlags.GradualCallableForm */;
         // Mark the function as synthesized since there is no user-defined declaration for it.
-        newFunction.details.flags |= 64 /* FunctionTypeFlags.SynthesizedMethod */;
-        delete newFunction.details.declaration;
+        newFunction.shared.flags |= 64 /* FunctionTypeFlags.SynthesizedMethod */;
+        if (newFunction.shared.declaration) {
+            newFunction.shared.declaration = undefined;
+        }
         // Update the specialized parameter types as well.
-        const specializedTypes = newFunction.specializedTypes;
+        const specializedTypes = newFunction.priv.specializedTypes;
         if (specializedTypes) {
-            paramSpecValue.details.parameters.forEach((paramInfo) => {
+            paramSpecValue.shared.parameters.forEach((paramInfo) => {
                 var _a;
                 specializedTypes.parameterTypes.push(paramInfo.type);
                 // Assume that the parameters introduced via paramSpec have no specialized
@@ -1109,11 +1226,11 @@ var FunctionType;
                 (_a = specializedTypes.parameterDefaultArgs) === null || _a === void 0 ? void 0 : _a.push(undefined);
             });
         }
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.details.typeVarScopeId);
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.details.higherOrderTypeVarScopeIds);
-        newFunction.details.constructorTypeVarScopeId = paramSpecValue.details.constructorTypeVarScopeId;
-        if (!newFunction.details.methodClass && paramSpecValue.details.methodClass) {
-            newFunction.details.methodClass = paramSpecValue.details.methodClass;
+        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.shared.typeVarScopeId);
+        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, paramSpecValue.priv.higherOrderTypeVarScopeIds);
+        newFunction.priv.constructorTypeVarScopeId = paramSpecValue.priv.constructorTypeVarScopeId;
+        if (!newFunction.shared.methodClass && paramSpecValue.shared.methodClass) {
+            newFunction.shared.methodClass = paramSpecValue.shared.methodClass;
         }
         return newFunction;
     }
@@ -1121,35 +1238,36 @@ var FunctionType;
     function cloneWithNewFlags(type, flags) {
         const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
-        newFunction.details = { ...type.details };
-        newFunction.details.flags = flags;
+        newFunction.shared = { ...type.shared };
+        newFunction.shared.flags = flags;
         return newFunction;
     }
     FunctionType.cloneWithNewFlags = cloneWithNewFlags;
-    function cloneWithNewTypeVarScopeId(type, newScopeId, typeParameters, trackedSignatures) {
+    function cloneWithNewTypeVarScopeId(type, newScopeId, newConstructorScopeId, typeParameters, trackedSignatures) {
         const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
-        newFunction.details = { ...type.details };
-        newFunction.details.typeVarScopeId = newScopeId;
-        newFunction.details.typeParameters = typeParameters;
-        newFunction.trackedSignatures = trackedSignatures;
-        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, typeParameters.map((t) => t.scopeId));
+        newFunction.shared = { ...type.shared };
+        newFunction.shared.typeVarScopeId = newScopeId;
+        newFunction.priv.constructorTypeVarScopeId = newConstructorScopeId;
+        newFunction.shared.typeParameters = typeParameters;
+        newFunction.priv.trackedSignatures = trackedSignatures;
+        FunctionType.addHigherOrderTypeVarScopeIds(newFunction, typeParameters.map((t) => t.priv.scopeId));
         return newFunction;
     }
     FunctionType.cloneWithNewTypeVarScopeId = cloneWithNewTypeVarScopeId;
     function cloneWithDocString(type, docString) {
         const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
-        newFunction.details = { ...type.details };
-        newFunction.details.docString = docString;
+        newFunction.shared = { ...type.shared };
+        newFunction.shared.docString = docString;
         return newFunction;
     }
     FunctionType.cloneWithDocString = cloneWithDocString;
     function cloneWithDeprecatedMessage(type, deprecatedMessage) {
         const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
-        newFunction.details = { ...type.details };
-        newFunction.details.deprecatedMessage = deprecatedMessage;
+        newFunction.shared = { ...type.shared };
+        newFunction.shared.deprecatedMessage = deprecatedMessage;
         return newFunction;
     }
     FunctionType.cloneWithDeprecatedMessage = cloneWithDeprecatedMessage;
@@ -1158,12 +1276,12 @@ var FunctionType;
     // *args and **kwargs parameters removed. If stripPositionOnlySeparator is true,
     // a trailing positional-only separator will be removed.
     function cloneRemoveParamSpecArgsKwargs(type, stripPositionOnlySeparator = false) {
-        const paramCount = type.details.parameters.length;
+        const paramCount = type.shared.parameters.length;
         if (paramCount < 2) {
             return type;
         }
-        const argsParam = type.details.parameters[paramCount - 2];
-        const kwargsParam = type.details.parameters[paramCount - 1];
+        const argsParam = type.shared.parameters[paramCount - 2];
+        const kwargsParam = type.shared.parameters[paramCount - 1];
         if (argsParam.category !== 1 /* ParameterCategory.ArgsList */ ||
             kwargsParam.category !== 2 /* ParameterCategory.KwargsDict */) {
             return type;
@@ -1175,8 +1293,8 @@ var FunctionType;
         }
         const newFunction = TypeBase.cloneType(type);
         // Make a shallow clone of the details.
-        newFunction.details = { ...type.details };
-        const details = newFunction.details;
+        newFunction.shared = { ...type.shared };
+        const details = newFunction.shared;
         let paramsToDrop = 2;
         // If the last remaining parameter is a position-only separator, remove it as well.
         // Always remove it if it's the only remaining parameter.
@@ -1187,16 +1305,16 @@ var FunctionType;
         }
         // Remove the last parameters, which are the *args and **kwargs.
         details.parameters = details.parameters.slice(0, details.parameters.length - paramsToDrop);
-        if (type.specializedTypes) {
-            newFunction.specializedTypes = { ...type.specializedTypes };
-            newFunction.specializedTypes.parameterTypes = newFunction.specializedTypes.parameterTypes.slice(0, newFunction.specializedTypes.parameterTypes.length - paramsToDrop);
-            if (newFunction.specializedTypes.parameterDefaultArgs) {
-                newFunction.specializedTypes.parameterDefaultArgs =
-                    newFunction.specializedTypes.parameterDefaultArgs.slice(0, newFunction.specializedTypes.parameterDefaultArgs.length - paramsToDrop);
+        if (type.priv.specializedTypes) {
+            newFunction.priv.specializedTypes = { ...type.priv.specializedTypes };
+            newFunction.priv.specializedTypes.parameterTypes = newFunction.priv.specializedTypes.parameterTypes.slice(0, newFunction.priv.specializedTypes.parameterTypes.length - paramsToDrop);
+            if (newFunction.priv.specializedTypes.parameterDefaultArgs) {
+                newFunction.priv.specializedTypes.parameterDefaultArgs =
+                    newFunction.priv.specializedTypes.parameterDefaultArgs.slice(0, newFunction.priv.specializedTypes.parameterDefaultArgs.length - paramsToDrop);
             }
         }
-        if (type.inferredReturnType) {
-            newFunction.inferredReturnType = type.inferredReturnType;
+        if (type.priv.inferredReturnType) {
+            newFunction.priv.inferredReturnType = type.priv.inferredReturnType;
         }
         return newFunction;
     }
@@ -1204,7 +1322,7 @@ var FunctionType;
     // If the function ends with "*args: P.args, **kwargs: P.kwargs", this function
     // returns P. Otherwise, it returns undefined.
     function getParamSpecFromArgsKwargs(type) {
-        const params = type.details.parameters;
+        const params = type.shared.parameters;
         if (params.length < 2) {
             return undefined;
         }
@@ -1212,28 +1330,18 @@ var FunctionType;
         const lastParam = params[params.length - 1];
         if (secondLastParam.category === 1 /* ParameterCategory.ArgsList */ &&
             isTypeVar(secondLastParam.type) &&
-            secondLastParam.type.paramSpecAccess === 'args' &&
+            secondLastParam.type.priv.paramSpecAccess === 'args' &&
             lastParam.category === 2 /* ParameterCategory.KwargsDict */ &&
             isTypeVar(lastParam.type) &&
-            lastParam.type.paramSpecAccess === 'kwargs') {
+            lastParam.type.priv.paramSpecAccess === 'kwargs') {
             return TypeVarType.cloneForParamSpecAccess(secondLastParam.type, /* access */ undefined);
         }
         return undefined;
     }
     FunctionType.getParamSpecFromArgsKwargs = getParamSpecFromArgsKwargs;
     function addParamSpecVariadics(type, paramSpec) {
-        FunctionType.addParameter(type, {
-            category: 1 /* ParameterCategory.ArgsList */,
-            name: 'args',
-            type: TypeVarType.cloneForParamSpecAccess(paramSpec, 'args'),
-            hasDeclaredType: true,
-        });
-        FunctionType.addParameter(type, {
-            category: 2 /* ParameterCategory.KwargsDict */,
-            name: 'kwargs',
-            type: TypeVarType.cloneForParamSpecAccess(paramSpec, 'kwargs'),
-            hasDeclaredType: true,
-        });
+        FunctionType.addParameter(type, FunctionParam.create(1 /* ParameterCategory.ArgsList */, TypeVarType.cloneForParamSpecAccess(paramSpec, 'args'), FunctionParamFlags.TypeDeclared, 'args'));
+        FunctionType.addParameter(type, FunctionParam.create(2 /* ParameterCategory.KwargsDict */, TypeVarType.cloneForParamSpecAccess(paramSpec, 'kwargs'), FunctionParamFlags.TypeDeclared, 'kwargs'));
     }
     FunctionType.addParamSpecVariadics = addParamSpecVariadics;
     function addDefaultParameters(type, useUnknown = false) {
@@ -1249,34 +1357,24 @@ var FunctionType;
         if (!Array.isArray(scopeIds)) {
             scopeIds = [scopeIds];
         }
-        if (!functionType.details.higherOrderTypeVarScopeIds) {
-            functionType.details.higherOrderTypeVarScopeIds = [];
+        if (!functionType.priv.higherOrderTypeVarScopeIds) {
+            functionType.priv.higherOrderTypeVarScopeIds = [];
         }
         // Add the scope IDs to the function if they're unique.
         scopeIds.forEach((scopeId) => {
-            if (!scopeId || scopeId === functionType.details.typeVarScopeId) {
+            if (!scopeId || scopeId === functionType.shared.typeVarScopeId) {
                 return;
             }
-            if (!functionType.details.higherOrderTypeVarScopeIds.some((id) => id === scopeId)) {
-                functionType.details.higherOrderTypeVarScopeIds.push(scopeId);
+            if (!functionType.priv.higherOrderTypeVarScopeIds.some((id) => id === scopeId)) {
+                functionType.priv.higherOrderTypeVarScopeIds.push(scopeId);
             }
         });
     }
     FunctionType.addHigherOrderTypeVarScopeIds = addHigherOrderTypeVarScopeIds;
     function getDefaultParameters(useUnknown = false) {
         return [
-            {
-                category: 1 /* ParameterCategory.ArgsList */,
-                name: 'args',
-                type: useUnknown ? UnknownType.create() : AnyType.create(),
-                hasDeclaredType: !useUnknown,
-            },
-            {
-                category: 2 /* ParameterCategory.KwargsDict */,
-                name: 'kwargs',
-                type: useUnknown ? UnknownType.create() : AnyType.create(),
-                hasDeclaredType: !useUnknown,
-            },
+            FunctionParam.create(1 /* ParameterCategory.ArgsList */, useUnknown ? UnknownType.create() : AnyType.create(), useUnknown ? FunctionParamFlags.None : FunctionParamFlags.TypeDeclared, 'args'),
+            FunctionParam.create(2 /* ParameterCategory.KwargsDict */, useUnknown ? UnknownType.create() : AnyType.create(), useUnknown ? FunctionParamFlags.None : FunctionParamFlags.TypeDeclared, 'kwargs'),
         ];
     }
     FunctionType.getDefaultParameters = getDefaultParameters;
@@ -1284,8 +1382,8 @@ var FunctionType;
     function hasDefaultParameters(functionType) {
         let sawArgs = false;
         let sawKwargs = false;
-        for (let i = 0; i < functionType.details.parameters.length; i++) {
-            const param = functionType.details.parameters[i];
+        for (let i = 0; i < functionType.shared.parameters.length; i++) {
+            const param = functionType.shared.parameters[i];
             // Ignore nameless separator parameters.
             if (!param.name) {
                 continue;
@@ -1307,7 +1405,7 @@ var FunctionType;
     }
     FunctionType.hasDefaultParameters = hasDefaultParameters;
     function isInstanceMethod(type) {
-        return ((type.details.flags &
+        return ((type.shared.flags &
             (1 /* FunctionTypeFlags.ConstructorMethod */ |
                 4 /* FunctionTypeFlags.StaticMethod */ |
                 2 /* FunctionTypeFlags.ClassMethod */)) ===
@@ -1315,128 +1413,134 @@ var FunctionType;
     }
     FunctionType.isInstanceMethod = isInstanceMethod;
     function isConstructorMethod(type) {
-        return (type.details.flags & 1 /* FunctionTypeFlags.ConstructorMethod */) !== 0;
+        return (type.shared.flags & 1 /* FunctionTypeFlags.ConstructorMethod */) !== 0;
     }
     FunctionType.isConstructorMethod = isConstructorMethod;
     function isStaticMethod(type) {
-        return (type.details.flags & 4 /* FunctionTypeFlags.StaticMethod */) !== 0;
+        return (type.shared.flags & 4 /* FunctionTypeFlags.StaticMethod */) !== 0;
     }
     FunctionType.isStaticMethod = isStaticMethod;
     function isClassMethod(type) {
-        return (type.details.flags & 2 /* FunctionTypeFlags.ClassMethod */) !== 0;
+        return (type.shared.flags & 2 /* FunctionTypeFlags.ClassMethod */) !== 0;
     }
     FunctionType.isClassMethod = isClassMethod;
     function isAbstractMethod(type) {
-        return (type.details.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0;
+        return (type.shared.flags & 8 /* FunctionTypeFlags.AbstractMethod */) !== 0;
     }
     FunctionType.isAbstractMethod = isAbstractMethod;
     function isGenerator(type) {
-        return (type.details.flags & 16 /* FunctionTypeFlags.Generator */) !== 0;
+        return (type.shared.flags & 16 /* FunctionTypeFlags.Generator */) !== 0;
     }
     FunctionType.isGenerator = isGenerator;
     function isSynthesizedMethod(type) {
-        return (type.details.flags & 64 /* FunctionTypeFlags.SynthesizedMethod */) !== 0;
+        return (type.shared.flags & 64 /* FunctionTypeFlags.SynthesizedMethod */) !== 0;
     }
     FunctionType.isSynthesizedMethod = isSynthesizedMethod;
     function isTypeCheckOnly(type) {
-        return (type.details.flags & 128 /* FunctionTypeFlags.TypeCheckOnly */) !== 0;
+        return (type.shared.flags & 128 /* FunctionTypeFlags.TypeCheckOnly */) !== 0;
     }
     FunctionType.isTypeCheckOnly = isTypeCheckOnly;
     function isOverloaded(type) {
-        return (type.details.flags & 256 /* FunctionTypeFlags.Overloaded */) !== 0;
+        return (type.shared.flags & 256 /* FunctionTypeFlags.Overloaded */) !== 0;
     }
     FunctionType.isOverloaded = isOverloaded;
     function isDefaultParameterCheckDisabled(type) {
-        return (type.details.flags & 32 /* FunctionTypeFlags.DisableDefaultChecks */) !== 0;
+        return (type.shared.flags & 32 /* FunctionTypeFlags.DisableDefaultChecks */) !== 0;
     }
     FunctionType.isDefaultParameterCheckDisabled = isDefaultParameterCheckDisabled;
     function isAsync(type) {
-        return (type.details.flags & 512 /* FunctionTypeFlags.Async */) !== 0;
+        return (type.shared.flags & 512 /* FunctionTypeFlags.Async */) !== 0;
     }
     FunctionType.isAsync = isAsync;
     function isStubDefinition(type) {
-        return (type.details.flags & 2048 /* FunctionTypeFlags.StubDefinition */) !== 0;
+        return (type.shared.flags & 2048 /* FunctionTypeFlags.StubDefinition */) !== 0;
     }
     FunctionType.isStubDefinition = isStubDefinition;
     function isPyTypedDefinition(type) {
-        return (type.details.flags & 4096 /* FunctionTypeFlags.PyTypedDefinition */) !== 0;
+        return (type.shared.flags & 4096 /* FunctionTypeFlags.PyTypedDefinition */) !== 0;
     }
     FunctionType.isPyTypedDefinition = isPyTypedDefinition;
     function isFinal(type) {
-        return (type.details.flags & 8192 /* FunctionTypeFlags.Final */) !== 0;
+        return (type.shared.flags & 8192 /* FunctionTypeFlags.Final */) !== 0;
     }
     FunctionType.isFinal = isFinal;
     function hasUnannotatedParams(type) {
-        return (type.details.flags & 16384 /* FunctionTypeFlags.UnannotatedParams */) !== 0;
+        return (type.shared.flags & 16384 /* FunctionTypeFlags.UnannotatedParams */) !== 0;
     }
     FunctionType.hasUnannotatedParams = hasUnannotatedParams;
     function isGradualCallableForm(type) {
-        return (type.details.flags & 32768 /* FunctionTypeFlags.GradualCallableForm */) !== 0;
+        return (type.shared.flags & 32768 /* FunctionTypeFlags.GradualCallableForm */) !== 0;
     }
     FunctionType.isGradualCallableForm = isGradualCallableForm;
     function isParamSpecValue(type) {
-        return (type.details.flags & 65536 /* FunctionTypeFlags.ParamSpecValue */) !== 0;
+        return (type.shared.flags & 65536 /* FunctionTypeFlags.ParamSpecValue */) !== 0;
     }
     FunctionType.isParamSpecValue = isParamSpecValue;
     function isPartiallyEvaluated(type) {
-        return !!(type.details.flags & 131072 /* FunctionTypeFlags.PartiallyEvaluated */);
+        return !!(type.shared.flags & 131072 /* FunctionTypeFlags.PartiallyEvaluated */);
     }
     FunctionType.isPartiallyEvaluated = isPartiallyEvaluated;
     function isOverridden(type) {
-        return !!(type.details.flags & 262144 /* FunctionTypeFlags.Overridden */);
+        return !!(type.shared.flags & 262144 /* FunctionTypeFlags.Overridden */);
     }
     FunctionType.isOverridden = isOverridden;
+    function isBuiltIn(type, name) {
+        if (!(type.shared.flags & 1048576 /* FunctionTypeFlags.BuiltIn */)) {
+            return false;
+        }
+        if (name !== undefined) {
+            const functionArray = Array.isArray(name) ? name : [name];
+            return functionArray.some((name) => name === type.shared.name);
+        }
+        return true;
+    }
+    FunctionType.isBuiltIn = isBuiltIn;
     function getEffectiveParameterType(type, index) {
-        (0, debug_1.assert)(index < type.details.parameters.length, 'Parameter types array overflow');
-        if (type.specializedTypes && index < type.specializedTypes.parameterTypes.length) {
-            return type.specializedTypes.parameterTypes[index];
+        (0, debug_1.assert)(index < type.shared.parameters.length, 'Parameter types array overflow');
+        if (type.priv.specializedTypes && index < type.priv.specializedTypes.parameterTypes.length) {
+            return type.priv.specializedTypes.parameterTypes[index];
         }
-        return type.details.parameters[index].type;
+        return type.shared.parameters[index].type;
     }
     FunctionType.getEffectiveParameterType = getEffectiveParameterType;
     function getEffectiveParameterDefaultArgType(type, index) {
         var _a;
-        (0, debug_1.assert)(index < type.details.parameters.length, 'Parameter types array overflow');
-        if (((_a = type.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultArgs) && index < type.specializedTypes.parameterDefaultArgs.length) {
-            const defaultArgType = type.specializedTypes.parameterDefaultArgs[index];
+        (0, debug_1.assert)(index < type.shared.parameters.length, 'Parameter types array overflow');
+        if (((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.parameterDefaultArgs) &&
+            index < type.priv.specializedTypes.parameterDefaultArgs.length) {
+            const defaultArgType = type.priv.specializedTypes.parameterDefaultArgs[index];
             if (defaultArgType) {
                 return defaultArgType;
             }
         }
-        return type.details.parameters[index].defaultType;
+        return type.shared.parameters[index].defaultType;
     }
     FunctionType.getEffectiveParameterDefaultArgType = getEffectiveParameterDefaultArgType;
     function addParameter(type, param) {
-        type.details.parameters.push(param);
-        if (type.specializedTypes) {
-            type.specializedTypes.parameterTypes.push(param.type);
+        type.shared.parameters.push(param);
+        if (type.priv.specializedTypes) {
+            type.priv.specializedTypes.parameterTypes.push(param.type);
         }
     }
     FunctionType.addParameter = addParameter;
     function addPositionOnlyParameterSeparator(type) {
-        addParameter(type, {
-            category: 0 /* ParameterCategory.Simple */,
-            type: AnyType.create(),
-        });
+        addParameter(type, FunctionParam.create(0 /* ParameterCategory.Simple */, AnyType.create()));
     }
     FunctionType.addPositionOnlyParameterSeparator = addPositionOnlyParameterSeparator;
     function addKeywordOnlyParameterSeparator(type) {
-        addParameter(type, {
-            category: 1 /* ParameterCategory.ArgsList */,
-            type: AnyType.create(),
-        });
+        addParameter(type, FunctionParam.create(1 /* ParameterCategory.ArgsList */, AnyType.create()));
     }
     FunctionType.addKeywordOnlyParameterSeparator = addKeywordOnlyParameterSeparator;
     function getEffectiveReturnType(type, includeInferred = true) {
         var _a;
-        if ((_a = type.specializedTypes) === null || _a === void 0 ? void 0 : _a.returnType) {
-            return type.specializedTypes.returnType;
+        if ((_a = type.priv.specializedTypes) === null || _a === void 0 ? void 0 : _a.returnType) {
+            return type.priv.specializedTypes.returnType;
         }
-        if (type.details.declaredReturnType) {
-            return type.details.declaredReturnType;
+        if (type.shared.declaredReturnType) {
+            return type.shared.declaredReturnType;
         }
         if (includeInferred) {
-            return type.inferredReturnType;
+            return type.priv.inferredReturnType;
         }
         return undefined;
     }
@@ -1447,8 +1551,13 @@ var OverloadedFunctionType;
     function create(overloads) {
         const newType = {
             category: 5 /* TypeCategory.OverloadedFunction */,
-            overloads: [],
             flags: 2 /* TypeFlags.Instance */,
+            props: undefined,
+            cached: undefined,
+            shared: undefined,
+            priv: {
+                overloads: [],
+            },
         };
         overloads.forEach((overload) => {
             OverloadedFunctionType.addOverload(newType, overload);
@@ -1458,16 +1567,16 @@ var OverloadedFunctionType;
     OverloadedFunctionType.create = create;
     // Adds a new overload or an implementation.
     function addOverload(type, functionType) {
-        functionType.overloaded = type;
-        type.overloads.push(functionType);
+        functionType.priv.overloaded = type;
+        type.priv.overloads.push(functionType);
     }
     OverloadedFunctionType.addOverload = addOverload;
     function getOverloads(type) {
-        return type.overloads.filter((func) => FunctionType.isOverloaded(func));
+        return type.priv.overloads.filter((func) => FunctionType.isOverloaded(func));
     }
     OverloadedFunctionType.getOverloads = getOverloads;
     function getImplementation(type) {
-        return type.overloads.find((func) => !FunctionType.isOverloaded(func));
+        return type.priv.overloads.find((func) => !FunctionType.isOverloaded(func));
     }
     OverloadedFunctionType.getImplementation = getImplementation;
 })(OverloadedFunctionType || (exports.OverloadedFunctionType = OverloadedFunctionType = {}));
@@ -1476,12 +1585,18 @@ var NeverType;
     const _neverInstance = {
         category: 3 /* TypeCategory.Never */,
         flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
-        isNoReturn: false,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: { isNoReturn: false },
     };
     const _noReturnInstance = {
         category: 3 /* TypeCategory.Never */,
         flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
-        isNoReturn: true,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: { isNoReturn: true },
     };
     function createNever() {
         return _neverInstance;
@@ -1492,11 +1607,12 @@ var NeverType;
     }
     NeverType.createNoReturn = createNoReturn;
     function convertToInstance(type) {
+        var _a;
         // Remove the "special form" if present. Otherwise return the existing type.
-        if (!type.specialForm) {
+        if (!((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm)) {
             return type;
         }
-        return type.isNoReturn ? NeverType.createNoReturn() : NeverType.createNever();
+        return type.priv.isNoReturn ? NeverType.createNoReturn() : NeverType.createNever();
     }
     NeverType.convertToInstance = convertToInstance;
 })(NeverType || (exports.NeverType = NeverType = {}));
@@ -1504,18 +1620,27 @@ var AnyType;
 (function (AnyType) {
     const _anyInstanceSpecialForm = {
         category: 2 /* TypeCategory.Any */,
-        isEllipsis: false,
         flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: { isEllipsis: false },
     };
     const _anyInstance = {
         category: 2 /* TypeCategory.Any */,
-        isEllipsis: false,
         flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: { isEllipsis: false },
     };
     const _ellipsisInstance = {
         category: 2 /* TypeCategory.Any */,
-        isEllipsis: true,
         flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
+        props: undefined,
+        cached: undefined,
+        shared: undefined,
+        priv: { isEllipsis: true },
     };
     function create(isEllipsis = false) {
         return isEllipsis ? _ellipsisInstance : _anyInstance;
@@ -1528,8 +1653,9 @@ var AnyType;
 })(AnyType || (exports.AnyType = AnyType = {}));
 (function (AnyType) {
     function convertToInstance(type) {
+        var _a;
         // Remove the "special form" if present. Otherwise return the existing type.
-        return type.specialForm ? AnyType.create() : type;
+        return ((_a = type.props) === null || _a === void 0 ? void 0 : _a.specialForm) ? AnyType.create() : type;
     }
     AnyType.convertToInstance = convertToInstance;
 })(AnyType || (exports.AnyType = AnyType = {}));
@@ -1554,10 +1680,10 @@ var TypeCondition;
     }
     TypeCondition.combine = combine;
     function _compare(c1, c2) {
-        if (c1.typeVar.details.name < c2.typeVar.details.name) {
+        if (c1.typeVar.shared.name < c2.typeVar.shared.name) {
             return -1;
         }
-        else if (c1.typeVar.details.name > c2.typeVar.details.name) {
+        else if (c1.typeVar.shared.name > c2.typeVar.shared.name) {
             return 1;
         }
         if (c1.constraintIndex < c2.constraintIndex) {
@@ -1575,7 +1701,7 @@ var TypeCondition;
         if (!conditions2 || conditions1.length !== conditions2.length) {
             return false;
         }
-        return (conditions1.find((c1, index) => c1.typeVar.nameWithScope !== conditions2[index].typeVar.nameWithScope ||
+        return (conditions1.find((c1, index) => c1.typeVar.priv.nameWithScope !== conditions2[index].typeVar.priv.nameWithScope ||
             c1.constraintIndex !== conditions2[index].constraintIndex) === undefined);
     }
     TypeCondition.isSame = isSame;
@@ -1590,7 +1716,7 @@ var TypeCondition;
         for (const c1 of conditions1) {
             let foundTypeVarMatch = false;
             const exactMatch = conditions2.find((c2) => {
-                if (c1.typeVar.nameWithScope === c2.typeVar.nameWithScope) {
+                if (c1.typeVar.priv.nameWithScope === c2.typeVar.priv.nameWithScope) {
                     foundTypeVarMatch = true;
                     return c1.constraintIndex === c2.constraintIndex;
                 }
@@ -1609,46 +1735,64 @@ var UnionType;
     function create() {
         const newUnionType = {
             category: 8 /* TypeCategory.Union */,
-            subtypes: [],
-            literalInstances: {},
-            literalClasses: {},
             flags: 2 /* TypeFlags.Instance */ | 1 /* TypeFlags.Instantiable */,
+            props: undefined,
+            cached: undefined,
+            shared: undefined,
+            priv: {
+                subtypes: [],
+                literalInstances: {
+                    literalStrMap: undefined,
+                    literalIntMap: undefined,
+                    literalEnumMap: undefined,
+                },
+                literalClasses: {
+                    literalStrMap: undefined,
+                    literalIntMap: undefined,
+                    literalEnumMap: undefined,
+                },
+                typeAliasSources: undefined,
+                includesRecursiveTypeAlias: false,
+            },
         };
         return newUnionType;
     }
     UnionType.create = create;
     function addType(unionType, newType) {
+        var _a, _b;
         // If we're adding a string, integer or enum literal, add it to the
         // corresponding literal map to speed up some operations. It's not
         // uncommon for unions to contain hundreds of literals.
-        if (isClass(newType) && newType.literalValue !== undefined && newType.condition === undefined) {
-            const literalMaps = isClassInstance(newType) ? unionType.literalInstances : unionType.literalClasses;
+        if (isClass(newType) && newType.priv.literalValue !== undefined && !((_a = newType.props) === null || _a === void 0 ? void 0 : _a.condition)) {
+            const literalMaps = isClassInstance(newType)
+                ? unionType.priv.literalInstances
+                : unionType.priv.literalClasses;
             if (ClassType.isBuiltIn(newType, 'str')) {
                 if (literalMaps.literalStrMap === undefined) {
                     literalMaps.literalStrMap = new Map();
                 }
-                literalMaps.literalStrMap.set(newType.literalValue, newType);
+                literalMaps.literalStrMap.set(newType.priv.literalValue, newType);
             }
             else if (ClassType.isBuiltIn(newType, 'int')) {
                 if (literalMaps.literalIntMap === undefined) {
                     literalMaps.literalIntMap = new Map();
                 }
-                literalMaps.literalIntMap.set(newType.literalValue, newType);
+                literalMaps.literalIntMap.set(newType.priv.literalValue, newType);
             }
             else if (ClassType.isEnumClass(newType)) {
                 if (literalMaps.literalEnumMap === undefined) {
                     literalMaps.literalEnumMap = new Map();
                 }
-                const enumLiteral = newType.literalValue;
+                const enumLiteral = newType.priv.literalValue;
                 literalMaps.literalEnumMap.set(enumLiteral.getName(), newType);
             }
         }
         unionType.flags &= newType.flags;
-        unionType.subtypes.push(newType);
-        if (isTypeVar(newType) && newType.details.recursiveTypeAliasName) {
+        unionType.priv.subtypes.push(newType);
+        if (isTypeVar(newType) && ((_b = newType.shared.recursiveAlias) === null || _b === void 0 ? void 0 : _b.name)) {
             // Note that at least one recursive type alias was included in
             // this union. We'll need to expand it before the union is used.
-            unionType.includesRecursiveTypeAlias = true;
+            unionType.priv.includesRecursiveTypeAlias = true;
         }
     }
     UnionType.addType = addType;
@@ -1656,22 +1800,25 @@ var UnionType;
     // the method skips any subtype indexes that are in the set and adds a found index to
     // the exclusion set. This speeds up union type comparisons.
     function containsType(unionType, subtype, exclusionSet, recursionCount = 0) {
+        var _a;
         // Handle string literals as a special case because unions can sometimes
         // contain hundreds of string literal types.
-        if (isClass(subtype) && subtype.condition === undefined && subtype.literalValue !== undefined) {
-            const literalMaps = isClassInstance(subtype) ? unionType.literalInstances : unionType.literalClasses;
+        if (isClass(subtype) && ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.condition) === undefined && subtype.priv.literalValue !== undefined) {
+            const literalMaps = isClassInstance(subtype)
+                ? unionType.priv.literalInstances
+                : unionType.priv.literalClasses;
             if (ClassType.isBuiltIn(subtype, 'str') && literalMaps.literalStrMap !== undefined) {
-                return literalMaps.literalStrMap.has(subtype.literalValue);
+                return literalMaps.literalStrMap.has(subtype.priv.literalValue);
             }
             else if (ClassType.isBuiltIn(subtype, 'int') && literalMaps.literalIntMap !== undefined) {
-                return literalMaps.literalIntMap.has(subtype.literalValue);
+                return literalMaps.literalIntMap.has(subtype.priv.literalValue);
             }
             else if (ClassType.isEnumClass(subtype) && literalMaps.literalEnumMap !== undefined) {
-                const enumLiteral = subtype.literalValue;
+                const enumLiteral = subtype.priv.literalValue;
                 return literalMaps.literalEnumMap.has(enumLiteral.getName());
             }
         }
-        const foundIndex = unionType.subtypes.findIndex((t, i) => {
+        const foundIndex = unionType.priv.subtypes.findIndex((t, i) => {
             if (exclusionSet === null || exclusionSet === void 0 ? void 0 : exclusionSet.has(i)) {
                 return false;
             }
@@ -1685,14 +1832,17 @@ var UnionType;
     }
     UnionType.containsType = containsType;
     function addTypeAliasSource(unionType, typeAliasSource) {
+        var _a;
         if (typeAliasSource.category === 8 /* TypeCategory.Union */) {
-            const sourcesToAdd = typeAliasSource.typeAliasInfo ? [typeAliasSource] : typeAliasSource.typeAliasSources;
+            const sourcesToAdd = ((_a = typeAliasSource.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo)
+                ? [typeAliasSource]
+                : typeAliasSource.priv.typeAliasSources;
             if (sourcesToAdd) {
-                if (!unionType.typeAliasSources) {
-                    unionType.typeAliasSources = new Set();
+                if (!unionType.priv.typeAliasSources) {
+                    unionType.priv.typeAliasSources = new Set();
                 }
                 sourcesToAdd.forEach((source) => {
-                    unionType.typeAliasSources.add(source);
+                    unionType.priv.typeAliasSources.add(source);
                 });
             }
         }
@@ -1724,13 +1874,15 @@ var TypeVarType;
     }
     TypeVarType.createInstantiable = createInstantiable;
     function cloneAsInstance(type) {
-        var _a;
+        var _a, _b;
         (0, debug_1.assert)(TypeBase.isInstantiable(type));
         if ((_a = type.cached) === null || _a === void 0 ? void 0 : _a.typeBaseInstanceType) {
             return type.cached.typeBaseInstanceType;
         }
         const newInstance = TypeBase.cloneTypeAsInstance(type, /* cache */ true);
-        delete newInstance.specialForm;
+        if ((_b = newInstance.props) === null || _b === void 0 ? void 0 : _b.specialForm) {
+            TypeBase.setSpecialForm(newInstance, undefined);
+        }
         return newInstance;
     }
     TypeVarType.cloneAsInstance = cloneAsInstance;
@@ -1745,36 +1897,36 @@ var TypeVarType;
     TypeVarType.cloneAsInstantiable = cloneAsInstantiable;
     function cloneForNewName(type, name) {
         const newInstance = TypeBase.cloneType(type);
-        newInstance.details = { ...type.details };
-        newInstance.details.name = name;
-        if (newInstance.scopeId) {
-            newInstance.nameWithScope = makeNameWithScope(name, newInstance.scopeId);
+        newInstance.shared = { ...type.shared };
+        newInstance.shared.name = name;
+        if (newInstance.priv.scopeId) {
+            newInstance.priv.nameWithScope = makeNameWithScope(name, newInstance.priv.scopeId);
         }
         return newInstance;
     }
     TypeVarType.cloneForNewName = cloneForNewName;
     function cloneForScopeId(type, scopeId, scopeName, scopeType) {
         const newInstance = TypeBase.cloneType(type);
-        newInstance.nameWithScope = makeNameWithScope(type.details.name, scopeId);
-        newInstance.scopeId = scopeId;
-        newInstance.scopeName = scopeName;
-        newInstance.scopeType = scopeType;
+        newInstance.priv.nameWithScope = makeNameWithScope(type.shared.name, scopeId);
+        newInstance.priv.scopeId = scopeId;
+        newInstance.priv.scopeName = scopeName;
+        newInstance.priv.scopeType = scopeType;
         return newInstance;
     }
     TypeVarType.cloneForScopeId = cloneForScopeId;
     function cloneForUnpacked(type, isInUnion = false) {
-        (0, debug_1.assert)(type.details.isVariadic);
+        (0, debug_1.assert)(type.shared.isVariadic);
         const newInstance = TypeBase.cloneType(type);
-        newInstance.isVariadicUnpacked = true;
-        newInstance.isVariadicInUnion = isInUnion;
+        newInstance.priv.isVariadicUnpacked = true;
+        newInstance.priv.isVariadicInUnion = isInUnion;
         return newInstance;
     }
     TypeVarType.cloneForUnpacked = cloneForUnpacked;
     function cloneForPacked(type) {
-        (0, debug_1.assert)(type.details.isVariadic);
+        (0, debug_1.assert)(type.shared.isVariadic);
         const newInstance = TypeBase.cloneType(type);
-        newInstance.isVariadicUnpacked = false;
-        newInstance.isVariadicInUnion = false;
+        newInstance.priv.isVariadicUnpacked = false;
+        newInstance.priv.isVariadicInUnion = false;
         return newInstance;
     }
     TypeVarType.cloneForPacked = cloneForPacked;
@@ -1782,55 +1934,55 @@ var TypeVarType;
     // and no bound or constraints. ParamSpecs and variadics are left
     // unmodified. So are auto-variant type variables.
     function cloneAsInvariant(type) {
-        if (type.details.isParamSpec || type.details.isVariadic) {
+        if (type.shared.isParamSpec || type.shared.isVariadic) {
             return type;
         }
-        if (type.details.declaredVariance === 0 /* Variance.Auto */) {
+        if (type.shared.declaredVariance === 0 /* Variance.Auto */) {
             return type;
         }
-        if (type.details.declaredVariance === 2 /* Variance.Invariant */) {
-            if (type.details.boundType === undefined && type.details.constraints.length === 0) {
+        if (type.shared.declaredVariance === 2 /* Variance.Invariant */) {
+            if (type.shared.boundType === undefined && type.shared.constraints.length === 0) {
                 return type;
             }
         }
         const newInstance = TypeBase.cloneType(type);
-        newInstance.details = { ...newInstance.details };
-        newInstance.details.declaredVariance = 2 /* Variance.Invariant */;
-        newInstance.details.boundType = undefined;
-        newInstance.details.constraints = [];
+        newInstance.shared = { ...newInstance.shared };
+        newInstance.shared.declaredVariance = 2 /* Variance.Invariant */;
+        newInstance.shared.boundType = undefined;
+        newInstance.shared.constraints = [];
         return newInstance;
     }
     TypeVarType.cloneAsInvariant = cloneAsInvariant;
     function cloneForParamSpecAccess(type, access) {
         const newInstance = TypeBase.cloneType(type);
-        newInstance.paramSpecAccess = access;
+        newInstance.priv.paramSpecAccess = access;
         return newInstance;
     }
     TypeVarType.cloneForParamSpecAccess = cloneForParamSpecAccess;
     function cloneAsSpecializedSelf(type, specializedBoundType) {
-        (0, debug_1.assert)(type.details.isSynthesizedSelf);
+        (0, debug_1.assert)(type.shared.isSynthesizedSelf);
         const newInstance = TypeBase.cloneType(type);
-        newInstance.details = { ...newInstance.details };
-        newInstance.details.boundType = specializedBoundType;
+        newInstance.shared = { ...newInstance.shared };
+        newInstance.shared.boundType = specializedBoundType;
         return newInstance;
     }
     TypeVarType.cloneAsSpecializedSelf = cloneAsSpecializedSelf;
     function cloneAsInScopePlaceholder(type, usageOffset) {
-        if (type.isInScopePlaceholder) {
+        if (type.priv.isInScopePlaceholder) {
             return type;
         }
         // If the caller specified a usage offset, append it to the TypeVar
         // internal name. This allows us to distinguish it from other uses
         // of the same TypeVar. For example nested calls to a generic
         // function like `foo(foo(1))`.
-        let newNameWithScope = type.nameWithScope;
+        let newNameWithScope = type.priv.nameWithScope;
         if (usageOffset) {
-            newNameWithScope = `${type.nameWithScope}-${usageOffset}`;
+            newNameWithScope = `${type.priv.nameWithScope}-${usageOffset}`;
         }
         const newInstance = TypeBase.cloneType(type);
-        newInstance.isInScopePlaceholder = true;
-        newInstance.scopeId = exports.InScopePlaceholderScopeId;
-        newInstance.nameWithScope = newNameWithScope;
+        newInstance.priv.isInScopePlaceholder = true;
+        newInstance.priv.scopeId = exports.InScopePlaceholderScopeId;
+        newInstance.priv.nameWithScope = newNameWithScope;
         return newInstance;
     }
     TypeVarType.cloneAsInScopePlaceholder = cloneAsInScopePlaceholder;
@@ -1841,38 +1993,48 @@ var TypeVarType;
     function create(name, isParamSpec, typeFlags) {
         const newTypeVarType = {
             category: 9 /* TypeCategory.TypeVar */,
-            details: {
+            flags: typeFlags,
+            props: undefined,
+            cached: undefined,
+            shared: {
                 name,
                 constraints: [],
-                declaredVariance: 2 /* Variance.Invariant */,
+                boundType: undefined,
+                isDefaultExplicit: false,
+                defaultType: UnknownType.create(),
                 isParamSpec,
                 isVariadic: false,
+                declaredVariance: 2 /* Variance.Invariant */,
                 isSynthesized: false,
-                defaultType: UnknownType.create(),
+                isSynthesizedSelf: false,
+                synthesizedIndex: undefined,
+                isExemptFromBoundCheck: false,
+                isTypeParamSyntax: false,
+                recursiveAlias: undefined,
             },
-            flags: typeFlags,
+            priv: {},
         };
         return newTypeVarType;
     }
     function addConstraint(typeVarType, constraintType) {
-        typeVarType.details.constraints.push(constraintType);
+        typeVarType.shared.constraints.push(constraintType);
     }
     TypeVarType.addConstraint = addConstraint;
     function getNameWithScope(typeVarType) {
         // If there is no name with scope, fall back on the (unscoped) name.
-        return typeVarType.nameWithScope || typeVarType.details.name;
+        return typeVarType.priv.nameWithScope || typeVarType.shared.name;
     }
     TypeVarType.getNameWithScope = getNameWithScope;
     function getReadableName(typeVarType) {
-        if (typeVarType.scopeName) {
-            return `${typeVarType.details.name}@${typeVarType.scopeName}`;
+        if (typeVarType.priv.scopeName) {
+            return `${typeVarType.shared.name}@${typeVarType.priv.scopeName}`;
         }
-        return typeVarType.details.name;
+        return typeVarType.shared.name;
     }
     TypeVarType.getReadableName = getReadableName;
     function getVariance(type) {
         var _a;
-        const variance = (_a = type.computedVariance) !== null && _a !== void 0 ? _a : type.details.declaredVariance;
+        const variance = (_a = type.priv.computedVariance) !== null && _a !== void 0 ? _a : type.shared.declaredVariance;
         // By this point, the variance should have been inferred.
         (0, debug_1.assert)(variance !== 0 /* Variance.Auto */, 'Expected variance to be inferred');
         // If we're in the process of computing variance, it will still be
@@ -1886,7 +2048,7 @@ var TypeVarType;
     // Indicates whether the specified type is a recursive type alias
     // placeholder that has not yet been resolved.
     function isTypeAliasPlaceholder(type) {
-        return !!type.details.recursiveTypeAliasName && !type.details.boundType;
+        return !!type.shared.recursiveAlias && !type.shared.boundType;
     }
     TypeVarType.isTypeAliasPlaceholder = isTypeAliasPlaceholder;
 })(TypeVarType || (exports.TypeVarType = TypeVarType = {}));
@@ -1907,7 +2069,7 @@ function isAnyOrUnknown(type) {
         return true;
     }
     if (isUnion(type)) {
-        return type.subtypes.find((subtype) => !isAnyOrUnknown(subtype)) === undefined;
+        return type.priv.subtypes.find((subtype) => !isAnyOrUnknown(subtype)) === undefined;
     }
     return false;
 }
@@ -1925,7 +2087,7 @@ function isPossiblyUnbound(type) {
         return true;
     }
     if (isUnion(type)) {
-        return type.subtypes.find((subtype) => isPossiblyUnbound(subtype)) !== undefined;
+        return type.priv.subtypes.find((subtype) => isPossiblyUnbound(subtype)) !== undefined;
     }
     return false;
 }
@@ -1951,18 +2113,18 @@ function isTypeVar(type) {
 }
 exports.isTypeVar = isTypeVar;
 function isVariadicTypeVar(type) {
-    return type.category === 9 /* TypeCategory.TypeVar */ && type.details.isVariadic;
+    return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.isVariadic;
 }
 exports.isVariadicTypeVar = isVariadicTypeVar;
 function isUnpackedVariadicTypeVar(type) {
     return (type.category === 9 /* TypeCategory.TypeVar */ &&
-        type.details.isVariadic &&
-        !!type.isVariadicUnpacked &&
-        !type.isVariadicInUnion);
+        type.shared.isVariadic &&
+        !!type.priv.isVariadicUnpacked &&
+        !type.priv.isVariadicInUnion);
 }
 exports.isUnpackedVariadicTypeVar = isUnpackedVariadicTypeVar;
 function isUnpackedClass(type) {
-    if (!isClass(type) || !type.isUnpacked) {
+    if (!isClass(type) || !type.priv.isUnpacked) {
         return false;
     }
     return true;
@@ -1973,7 +2135,7 @@ function isUnpacked(type) {
 }
 exports.isUnpacked = isUnpacked;
 function isParamSpec(type) {
-    return type.category === 9 /* TypeCategory.TypeVar */ && type.details.isParamSpec;
+    return type.category === 9 /* TypeCategory.TypeVar */ && type.shared.isParamSpec;
 }
 exports.isParamSpec = isParamSpec;
 function isFunction(type) {
@@ -1985,14 +2147,15 @@ function isOverloadedFunction(type) {
 }
 exports.isOverloadedFunction = isOverloadedFunction;
 function getTypeAliasInfo(type) {
-    if (type.typeAliasInfo) {
-        return type.typeAliasInfo;
+    var _a, _b;
+    if ((_a = type.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
+        return type.props.typeAliasInfo;
     }
     if (isTypeVar(type) &&
-        type.details.recursiveTypeAliasName &&
-        type.details.boundType &&
-        type.details.boundType.typeAliasInfo) {
-        return type.details.boundType.typeAliasInfo;
+        type.shared.recursiveAlias &&
+        type.shared.boundType &&
+        ((_b = type.shared.boundType.props) === null || _b === void 0 ? void 0 : _b.typeAliasInfo)) {
+        return type.shared.boundType.props.typeAliasInfo;
     }
     return undefined;
 }
@@ -2001,7 +2164,7 @@ exports.getTypeAliasInfo = getTypeAliasInfo;
 // type arguments for "pseudo-generic" classes (non-generic classes whose init
 // methods are not annotated and are therefore treated as generic) are ignored.
 function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f;
     if (type1 === type2) {
         return true;
     }
@@ -2017,7 +2180,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         return false;
     }
     if (!options.ignoreTypeFlags) {
-        if (type1.flags !== type2.flags) {
+        if ((type1.flags & 3 /* TypeFlags.TypeCompatibilityMask */) !== (type2.flags & 3 /* TypeFlags.TypeCompatibilityMask */)) {
             return false;
         }
     }
@@ -2032,14 +2195,14 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             if (!ClassType.isSameGenericClass(type1, classType2, recursionCount)) {
                 return false;
             }
-            if (!options.ignoreConditions && !TypeCondition.isSame(type1.condition, type2.condition)) {
+            if (!options.ignoreConditions && !TypeCondition.isSame((_a = type1.props) === null || _a === void 0 ? void 0 : _a.condition, (_b = type2.props) === null || _b === void 0 ? void 0 : _b.condition)) {
                 return false;
             }
             if (!options.ignorePseudoGeneric || !ClassType.isPseudoGenericClass(type1)) {
                 // Make sure the type args match.
-                if (type1.tupleTypeArguments && classType2.tupleTypeArguments) {
-                    const type1TupleTypeArgs = type1.tupleTypeArguments || [];
-                    const type2TupleTypeArgs = classType2.tupleTypeArguments || [];
+                if (type1.priv.tupleTypeArguments && classType2.priv.tupleTypeArguments) {
+                    const type1TupleTypeArgs = type1.priv.tupleTypeArguments || [];
+                    const type2TupleTypeArgs = classType2.priv.tupleTypeArguments || [];
                     if (type1TupleTypeArgs.length !== type2TupleTypeArgs.length) {
                         return false;
                     }
@@ -2053,8 +2216,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                     }
                 }
                 else {
-                    const type1TypeArgs = type1.typeArguments || [];
-                    const type2TypeArgs = classType2.typeArguments || [];
+                    const type1TypeArgs = type1.priv.typeArguments || [];
+                    const type2TypeArgs = classType2.priv.typeArguments || [];
                     const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
                     for (let i = 0; i < typeArgCount; i++) {
                         // Assume that missing type args are "Unknown".
@@ -2069,7 +2232,7 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             if (!ClassType.isLiteralValueSame(type1, classType2)) {
                 return false;
             }
-            if (!type1.isTypedDictPartial !== !classType2.isTypedDictPartial) {
+            if (!type1.priv.isTypedDictPartial !== !classType2.priv.isTypedDictPartial) {
                 return false;
             }
             if (!options.ignoreTypedDictNarrowEntries && !ClassType.isTypedDictNarrowedEntriesSame(type1, classType2)) {
@@ -2080,8 +2243,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         case 4 /* TypeCategory.Function */: {
             // Make sure the parameter counts match.
             const functionType2 = type2;
-            const params1 = type1.details.parameters;
-            const params2 = functionType2.details.parameters;
+            const params1 = type1.shared.parameters;
+            const params2 = functionType2.shared.parameters;
             if (params1.length !== params2.length) {
                 return false;
             }
@@ -2121,19 +2284,19 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                 }
             }
             // Make sure the return types match.
-            let return1Type = type1.details.declaredReturnType;
-            if (type1.specializedTypes && type1.specializedTypes.returnType) {
-                return1Type = type1.specializedTypes.returnType;
+            let return1Type = type1.shared.declaredReturnType;
+            if (type1.priv.specializedTypes && type1.priv.specializedTypes.returnType) {
+                return1Type = type1.priv.specializedTypes.returnType;
             }
-            if (!return1Type && type1.inferredReturnType) {
-                return1Type = type1.inferredReturnType;
+            if (!return1Type && type1.priv.inferredReturnType) {
+                return1Type = type1.priv.inferredReturnType;
             }
-            let return2Type = functionType2.details.declaredReturnType;
-            if (functionType2.specializedTypes && functionType2.specializedTypes.returnType) {
-                return2Type = functionType2.specializedTypes.returnType;
+            let return2Type = functionType2.shared.declaredReturnType;
+            if (functionType2.priv.specializedTypes && functionType2.priv.specializedTypes.returnType) {
+                return2Type = functionType2.priv.specializedTypes.returnType;
             }
-            if (!return2Type && functionType2.inferredReturnType) {
-                return2Type = functionType2.inferredReturnType;
+            if (!return2Type && functionType2.priv.inferredReturnType) {
+                return2Type = functionType2.priv.inferredReturnType;
             }
             if (return1Type || return2Type) {
                 if (!return1Type ||
@@ -2147,13 +2310,13 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         case 5 /* TypeCategory.OverloadedFunction */: {
             // Make sure the overload counts match.
             const functionType2 = type2;
-            if (type1.overloads.length !== functionType2.overloads.length) {
+            if (type1.priv.overloads.length !== functionType2.priv.overloads.length) {
                 return false;
             }
             // We assume here that overloaded functions always appear
             // in the same order from one analysis pass to another.
-            for (let i = 0; i < type1.overloads.length; i++) {
-                if (!isTypeSame(type1.overloads[i], functionType2.overloads[i], options, recursionCount)) {
+            for (let i = 0; i < type1.priv.overloads.length; i++) {
+                if (!isTypeSame(type1.priv.overloads[i], functionType2.priv.overloads[i], options, recursionCount)) {
                     return false;
                 }
             }
@@ -2161,8 +2324,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         }
         case 8 /* TypeCategory.Union */: {
             const unionType2 = type2;
-            const subtypes1 = type1.subtypes;
-            const subtypes2 = unionType2.subtypes;
+            const subtypes1 = type1.priv.subtypes;
+            const subtypes2 = unionType2.priv.subtypes;
             if (subtypes1.length !== subtypes2.length) {
                 return false;
             }
@@ -2173,14 +2336,14 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
         }
         case 9 /* TypeCategory.TypeVar */: {
             const type2TypeVar = type2;
-            if (type1.scopeId !== type2TypeVar.scopeId) {
+            if (type1.priv.scopeId !== type2TypeVar.priv.scopeId) {
                 return false;
             }
             // Handle the case where this is a generic recursive type alias. Make
             // sure that the type argument types match.
-            if (type1.details.recursiveTypeParameters && type2TypeVar.details.recursiveTypeParameters) {
-                const type1TypeArgs = ((_a = type1 === null || type1 === void 0 ? void 0 : type1.typeAliasInfo) === null || _a === void 0 ? void 0 : _a.typeArguments) || [];
-                const type2TypeArgs = ((_b = type2 === null || type2 === void 0 ? void 0 : type2.typeAliasInfo) === null || _b === void 0 ? void 0 : _b.typeArguments) || [];
+            if (type1.shared.recursiveAlias && type2TypeVar.shared.recursiveAlias) {
+                const type1TypeArgs = ((_d = (_c = type1 === null || type1 === void 0 ? void 0 : type1.props) === null || _c === void 0 ? void 0 : _c.typeAliasInfo) === null || _d === void 0 ? void 0 : _d.typeArguments) || [];
+                const type2TypeArgs = ((_f = (_e = type2 === null || type2 === void 0 ? void 0 : type2.props) === null || _e === void 0 ? void 0 : _e.typeAliasInfo) === null || _f === void 0 ? void 0 : _f.typeArguments) || [];
                 const typeArgCount = Math.max(type1TypeArgs.length, type2TypeArgs.length);
                 for (let i = 0; i < typeArgCount; i++) {
                     // Assume that missing type args are "Any".
@@ -2191,22 +2354,22 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                     }
                 }
             }
-            if (!type1.isVariadicInUnion !== !type2TypeVar.isVariadicInUnion) {
+            if (!type1.priv.isVariadicInUnion !== !type2TypeVar.priv.isVariadicInUnion) {
                 return false;
             }
-            if (type1.details === type2TypeVar.details) {
+            if (type1.shared === type2TypeVar.shared) {
                 return true;
             }
-            if (type1.details.name !== type2TypeVar.details.name ||
-                type1.details.isParamSpec !== type2TypeVar.details.isParamSpec ||
-                type1.details.isVariadic !== type2TypeVar.details.isVariadic ||
-                type1.details.isSynthesized !== type2TypeVar.details.isSynthesized ||
-                type1.details.declaredVariance !== type2TypeVar.details.declaredVariance ||
-                type1.scopeId !== type2TypeVar.scopeId) {
+            if (type1.shared.name !== type2TypeVar.shared.name ||
+                type1.shared.isParamSpec !== type2TypeVar.shared.isParamSpec ||
+                type1.shared.isVariadic !== type2TypeVar.shared.isVariadic ||
+                type1.shared.isSynthesized !== type2TypeVar.shared.isSynthesized ||
+                type1.shared.declaredVariance !== type2TypeVar.shared.declaredVariance ||
+                type1.priv.scopeId !== type2TypeVar.priv.scopeId) {
                 return false;
             }
-            const boundType1 = type1.details.boundType;
-            const boundType2 = type2TypeVar.details.boundType;
+            const boundType1 = type1.shared.boundType;
+            const boundType2 = type2TypeVar.shared.boundType;
             if (boundType1) {
                 if (!boundType2 ||
                     !isTypeSame(boundType1, boundType2, { ...options, ignoreTypeFlags: false }, recursionCount)) {
@@ -2218,8 +2381,8 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
                     return false;
                 }
             }
-            const constraints1 = type1.details.constraints;
-            const constraints2 = type2TypeVar.details.constraints;
+            const constraints1 = type1.shared.constraints;
+            const constraints2 = type2TypeVar.shared.constraints;
             if (constraints1.length !== constraints2.length) {
                 return false;
             }
@@ -2234,19 +2397,19 @@ function isTypeSame(type1, type2, options = {}, recursionCount = 0) {
             const type2Module = type2;
             // Module types are the same if they share the same
             // module symbol table.
-            if (type1.fields === type2Module.fields) {
+            if (type1.priv.fields === type2Module.priv.fields) {
                 return true;
             }
             // If both symbol tables are empty, we can also assume
             // they're equal.
-            if (type1.fields.size === 0 && type2Module.fields.size === 0) {
+            if (type1.priv.fields.size === 0 && type2Module.priv.fields.size === 0) {
                 return true;
             }
             return false;
         }
         case 1 /* TypeCategory.Unknown */: {
             const type2Unknown = type2;
-            return type1.isIncomplete === type2Unknown.isIncomplete;
+            return type1.priv.isIncomplete === type2Unknown.priv.isIncomplete;
         }
     }
     return true;
@@ -2272,8 +2435,8 @@ function removeUnbound(type) {
 exports.removeUnbound = removeUnbound;
 function removeFromUnion(type, removeFilter) {
     if (isUnion(type)) {
-        const remainingTypes = type.subtypes.filter((t) => !removeFilter(t));
-        if (remainingTypes.length < type.subtypes.length) {
+        const remainingTypes = type.priv.subtypes.filter((t) => !removeFilter(t));
+        if (remainingTypes.length < type.priv.subtypes.length) {
             const newType = combineTypes(remainingTypes);
             if (isUnion(newType)) {
                 UnionType.addTypeAliasSource(newType, type);
@@ -2286,7 +2449,7 @@ function removeFromUnion(type, removeFilter) {
 exports.removeFromUnion = removeFromUnion;
 function findSubtype(type, filter) {
     if (isUnion(type)) {
-        return type.subtypes.find((subtype) => {
+        return type.priv.subtypes.find((subtype) => {
             return filter(subtype);
         });
     }
@@ -2297,12 +2460,13 @@ exports.findSubtype = findSubtype;
 // the same, only one is returned. If they differ, they
 // are combined into a UnionType. NeverTypes are filtered out.
 // If no types remain in the end, a NeverType is returned.
-function combineTypes(subtypes, maxSubtypeCount) {
+function combineTypes(subtypes, options) {
+    var _a;
     // Filter out any "Never" and "NoReturn" types.
     let sawNoReturn = false;
     if (subtypes.some((subtype) => subtype.category === 3 /* TypeCategory.Never */))
         subtypes = subtypes.filter((subtype) => {
-            if (subtype.category === 3 /* TypeCategory.Never */ && subtype.isNoReturn) {
+            if (subtype.category === 3 /* TypeCategory.Never */ && subtype.priv.isNoReturn) {
                 sawNoReturn = true;
             }
             return subtype.category !== 3 /* TypeCategory.Never */;
@@ -2333,12 +2497,12 @@ function combineTypes(subtypes, maxSubtypeCount) {
             if (!expandedTypes) {
                 expandedTypes = subtypes.slice(0, i);
             }
-            expandedTypes = expandedTypes.concat(subtype.subtypes);
-            if (subtype.typeAliasInfo) {
+            expandedTypes = expandedTypes.concat(subtype.priv.subtypes);
+            if ((_a = subtype.props) === null || _a === void 0 ? void 0 : _a.typeAliasInfo) {
                 typeAliasSources.add(subtype);
             }
-            else if (subtype.typeAliasSources) {
-                subtype.typeAliasSources.forEach((subtype) => {
+            else if (subtype.priv.typeAliasSources) {
+                subtype.priv.typeAliasSources.forEach((subtype) => {
                     typeAliasSources.add(subtype);
                 });
             }
@@ -2350,16 +2514,16 @@ function combineTypes(subtypes, maxSubtypeCount) {
     expandedTypes = expandedTypes !== null && expandedTypes !== void 0 ? expandedTypes : subtypes;
     // Sort all of the literal and empty types to the end.
     expandedTypes = expandedTypes.sort((type1, type2) => {
-        if (isClass(type1) && type1.literalValue !== undefined) {
+        if (isClass(type1) && type1.priv.literalValue !== undefined) {
             return 1;
         }
-        if (isClass(type2) && type2.literalValue !== undefined) {
+        if (isClass(type2) && type2.priv.literalValue !== undefined) {
             return -1;
         }
-        if (isClassInstance(type1) && type1.isEmptyContainer) {
+        if (isClassInstance(type1) && type1.priv.isEmptyContainer) {
             return 1;
         }
-        else if (isClassInstance(type2) && type2.isEmptyContainer) {
+        else if (isClassInstance(type2) && type2.priv.isEmptyContainer) {
             return -1;
         }
         return 0;
@@ -2371,7 +2535,7 @@ function combineTypes(subtypes, maxSubtypeCount) {
     }
     const newUnionType = UnionType.create();
     if (typeAliasSources.size > 0) {
-        newUnionType.typeAliasSources = typeAliasSources;
+        newUnionType.priv.typeAliasSources = typeAliasSources;
     }
     let hitMaxSubtypeCount = false;
     expandedTypes.forEach((subtype, index) => {
@@ -2379,8 +2543,8 @@ function combineTypes(subtypes, maxSubtypeCount) {
             UnionType.addType(newUnionType, subtype);
         }
         else {
-            if (maxSubtypeCount === undefined || newUnionType.subtypes.length < maxSubtypeCount) {
-                _addTypeIfUnique(newUnionType, subtype);
+            if ((options === null || options === void 0 ? void 0 : options.maxSubtypeCount) === undefined || newUnionType.priv.subtypes.length < options.maxSubtypeCount) {
+                _addTypeIfUnique(newUnionType, subtype, !(options === null || options === void 0 ? void 0 : options.skipElideRedundantLiterals));
             }
             else {
                 hitMaxSubtypeCount = true;
@@ -2391,8 +2555,8 @@ function combineTypes(subtypes, maxSubtypeCount) {
         return AnyType.create();
     }
     // If only one type remains, convert it from a union to a simple type.
-    if (newUnionType.subtypes.length === 1) {
-        return newUnionType.subtypes[0];
+    if (newUnionType.priv.subtypes.length === 1) {
+        return newUnionType.priv.subtypes[0];
     }
     return newUnionType;
 }
@@ -2405,12 +2569,12 @@ function isSameWithoutLiteralValue(destType, srcType) {
     if (isTypeSame(destType, srcType)) {
         return true;
     }
-    if (isInstantiableClass(srcType) && srcType.literalValue !== undefined) {
+    if (isInstantiableClass(srcType) && srcType.priv.literalValue !== undefined) {
         // Strip the literal.
         srcType = ClassType.cloneWithLiteral(srcType, /* value */ undefined);
         return isTypeSame(destType, srcType);
     }
-    if (isClassInstance(srcType) && srcType.literalValue !== undefined) {
+    if (isClassInstance(srcType) && srcType.priv.literalValue !== undefined) {
         // Strip the literal.
         srcType = ClassType.cloneWithLiteral(srcType, /* value */ undefined);
         return isTypeSame(destType, srcType, { ignoreConditions: true });
@@ -2418,32 +2582,35 @@ function isSameWithoutLiteralValue(destType, srcType) {
     return false;
 }
 exports.isSameWithoutLiteralValue = isSameWithoutLiteralValue;
-function _addTypeIfUnique(unionType, typeToAdd) {
+function _addTypeIfUnique(unionType, typeToAdd, elideRedundantLiterals) {
+    var _a, _b, _c;
     // Handle the addition of a string literal in a special manner to
     // avoid n^2 behavior in unions that contain hundreds of string
     // literal types. Skip this for constrained types.
-    if (isClass(typeToAdd) && typeToAdd.condition === undefined) {
-        const literalMaps = isClassInstance(typeToAdd) ? unionType.literalInstances : unionType.literalClasses;
+    if (isClass(typeToAdd) && !((_a = typeToAdd.props) === null || _a === void 0 ? void 0 : _a.condition)) {
+        const literalMaps = isClassInstance(typeToAdd)
+            ? unionType.priv.literalInstances
+            : unionType.priv.literalClasses;
         if (ClassType.isBuiltIn(typeToAdd, 'str') &&
-            typeToAdd.literalValue !== undefined &&
+            typeToAdd.priv.literalValue !== undefined &&
             literalMaps.literalStrMap !== undefined) {
-            if (!literalMaps.literalStrMap.has(typeToAdd.literalValue)) {
+            if (!literalMaps.literalStrMap.has(typeToAdd.priv.literalValue)) {
                 UnionType.addType(unionType, typeToAdd);
             }
             return;
         }
         else if (ClassType.isBuiltIn(typeToAdd, 'int') &&
-            typeToAdd.literalValue !== undefined &&
+            typeToAdd.priv.literalValue !== undefined &&
             literalMaps.literalIntMap !== undefined) {
-            if (!literalMaps.literalIntMap.has(typeToAdd.literalValue)) {
+            if (!literalMaps.literalIntMap.has(typeToAdd.priv.literalValue)) {
                 UnionType.addType(unionType, typeToAdd);
             }
             return;
         }
         else if (ClassType.isEnumClass(typeToAdd) &&
-            typeToAdd.literalValue !== undefined &&
+            typeToAdd.priv.literalValue !== undefined &&
             literalMaps.literalEnumMap !== undefined) {
-            const enumLiteral = typeToAdd.literalValue;
+            const enumLiteral = typeToAdd.priv.literalValue;
             if (!literalMaps.literalEnumMap.has(enumLiteral.getName())) {
                 UnionType.addType(unionType, typeToAdd);
             }
@@ -2451,8 +2618,8 @@ function _addTypeIfUnique(unionType, typeToAdd) {
         }
     }
     const isPseudoGeneric = isClass(typeToAdd) && ClassType.isPseudoGenericClass(typeToAdd);
-    for (let i = 0; i < unionType.subtypes.length; i++) {
-        const type = unionType.subtypes[i];
+    for (let i = 0; i < unionType.priv.subtypes.length; i++) {
+        const type = unionType.priv.subtypes[i];
         // Does this type already exist in the types array?
         if (isTypeSame(type, typeToAdd)) {
             return;
@@ -2465,27 +2632,28 @@ function _addTypeIfUnique(unionType, typeToAdd) {
         // parameterized with its own class) ad infinitum.
         if (isPseudoGeneric) {
             if (isTypeSame(type, typeToAdd, { ignorePseudoGeneric: true })) {
-                unionType.subtypes[i] = ClassType.cloneForSpecialization(typeToAdd, typeToAdd.details.typeParameters.map(() => UnknownType.create()), 
+                unionType.priv.subtypes[i] = ClassType.cloneForSpecialization(typeToAdd, typeToAdd.shared.typeParameters.map(() => UnknownType.create()), 
                 /* isTypeArgumentExplicit */ true);
                 return;
             }
         }
-        // If the typeToAdd is a literal value and there's already
-        // a non-literal type that matches, don't add the literal value.
         if (isClassInstance(type) && isClassInstance(typeToAdd)) {
-            if (isSameWithoutLiteralValue(type, typeToAdd)) {
-                if (type.literalValue === undefined) {
+            // If the typeToAdd is a literal value and there's already
+            // a non-literal type that matches, don't add the literal value.
+            if (elideRedundantLiterals && isSameWithoutLiteralValue(type, typeToAdd)) {
+                if (type.priv.literalValue === undefined) {
                     return;
                 }
             }
             // If we're adding Literal[False] or Literal[True] to its
             // opposite, combine them into a non-literal 'bool' type.
             if (ClassType.isBuiltIn(type, 'bool') &&
-                !type.condition &&
+                !((_b = type.props) === null || _b === void 0 ? void 0 : _b.condition) &&
                 ClassType.isBuiltIn(typeToAdd, 'bool') &&
-                !typeToAdd.condition) {
-                if (typeToAdd.literalValue !== undefined && !typeToAdd.literalValue === type.literalValue) {
-                    unionType.subtypes[i] = ClassType.cloneWithLiteral(type, /* value */ undefined);
+                !((_c = typeToAdd.props) === null || _c === void 0 ? void 0 : _c.condition)) {
+                if (typeToAdd.priv.literalValue !== undefined &&
+                    !typeToAdd.priv.literalValue === type.priv.literalValue) {
+                    unionType.priv.subtypes[i] = ClassType.cloneWithLiteral(type, /* value */ undefined);
                     return;
                 }
             }
@@ -2493,12 +2661,12 @@ function _addTypeIfUnique(unionType, typeToAdd) {
             // existing type, see if one of them is a proper subset of the other.
             if (ClassType.isTypedDictClass(type) && ClassType.isSameGenericClass(type, typeToAdd)) {
                 // Do not proceed if the TypedDicts are generic and have different type arguments.
-                if (!type.typeArguments && !typeToAdd.typeArguments) {
+                if (!type.priv.typeArguments && !typeToAdd.priv.typeArguments) {
                     if (ClassType.isTypedDictNarrower(typeToAdd, type)) {
                         return;
                     }
                     else if (ClassType.isTypedDictNarrower(type, typeToAdd)) {
-                        unionType.subtypes[i] = typeToAdd;
+                        unionType.priv.subtypes[i] = typeToAdd;
                         return;
                     }
                 }
@@ -2506,7 +2674,7 @@ function _addTypeIfUnique(unionType, typeToAdd) {
         }
         // If the typeToAdd is an empty container and there's already
         // non-empty container of the same type, don't add the empty container.
-        if (isClassInstance(typeToAdd) && typeToAdd.isEmptyContainer) {
+        if (isClassInstance(typeToAdd) && typeToAdd.priv.isEmptyContainer) {
             if (isClassInstance(type) && ClassType.isSameGenericClass(type, typeToAdd)) {
                 return;
             }