tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/checker-types.js

@@ -0,0 +1,1697 @@
+import { getSymbolId } from './symbol.js';
+/** The sign bit, which TypeScript enums can't hold as a positive flag. */
+export const typeFlagsReserved3 = -2147483648;
+export function cachedTypeKey(kind, id) {
+    return id * 32 + kind;
+}
+/** Type ids below this bound pack in pairs into a `cachedTypesByPair` key. */
+const CachedTypePairIdLimit = 1 << 24;
+/** The `cachedTypesByPair` key of two type ids and four bits, or -1 when an id is too large to pack. */
+export function cachedTypePairKey(a, b, bits) {
+    return a < CachedTypePairIdLimit && b < CachedTypePairIdLimit ? (a * CachedTypePairIdLimit + b) * 16 + bits : -1;
+}
+// ---- Types
+/** An alias symbol and its type arguments, for types written through a type alias. */
+export class TypeAlias {
+    symbol;
+    typeArguments;
+    constructor(symbol, typeArguments) {
+        this.symbol = symbol;
+        this.typeArguments = typeArguments;
+    }
+}
+/** One entry of a `TypeListCache`: the parts of its key, its value, and the next entry with the same hash. */
+class TypeListEntry {
+    types;
+    alias;
+    tag;
+    value;
+    next;
+    constructor(types, alias, tag, value) {
+        this.types = types;
+        this.alias = alias;
+        this.tag = tag;
+        this.value = value;
+        this.next = undefined;
+    }
+}
+function sameTypeListParts(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function sameAliasParts(a, b) {
+    if (a === undefined || b === undefined)
+        return a === b;
+    return a.symbol === b.symbol && sameTypeListParts(a.typeArguments, b.typeArguments);
+}
+/**
+ * Values keyed by a list of types, an optional alias and a small tag: the keys `typeListKey(types) +
+ * aliasKey(alias)` plus a suffix spelled, without building them. A lookup takes a number hashing the
+ * parts (`typeListHash`); entries keep their parts, so a match is exact and keys sharing a hash chain.
+ * Like tsgo's hashed type list keys. A list must not change after it keys an entry.
+ */
+export class TypeListCache {
+    entries = new Map();
+    get(hash, types, alias, tag) {
+        for (let e = this.entries.get(hash); e !== undefined; e = e.next)
+            if (e.tag === tag && sameTypeListParts(e.types, types) && sameAliasParts(e.alias, alias))
+                return e.value;
+        return undefined;
+    }
+    set(hash, types, alias, tag, value) {
+        const head = this.entries.get(hash);
+        if (head === undefined) {
+            this.entries.set(hash, new TypeListEntry(types, alias, tag, value));
+            return;
+        }
+        for (let e = head; e !== undefined; e = e.next)
+            if (e.tag === tag && sameTypeListParts(e.types, types) && sameAliasParts(e.alias, alias)) {
+                e.value = value;
+                return;
+            }
+        const entry = new TypeListEntry(types, alias, tag, value);
+        entry.next = head.next;
+        head.next = entry;
+    }
+    clear() {
+        this.entries.clear();
+    }
+}
+/**
+ * The references to a generic class, interface or tuple type, by the hash of their type arguments
+ * (`createTypeReference`). A reference is its own entry: a lookup compares its type arguments. A
+ * reference whose hash another reference has is kept in `collisions`.
+ */
+export class ReferenceCache {
+    references = new Map();
+    collisions = undefined;
+    get(hash, typeArguments) {
+        const reference = this.references.get(hash);
+        if (reference === undefined)
+            return undefined;
+        if (sameTypeListParts(reference.resolvedTypeArguments, typeArguments))
+            return reference;
+        const collisions = this.collisions;
+        return collisions !== undefined ? collisions.get(hash, typeArguments, undefined, 0) : undefined;
+    }
+    /** Adds `reference`, whose type arguments `get` did not find. */
+    add(hash, reference) {
+        if (this.references.get(hash) === undefined) {
+            this.references.set(hash, reference);
+            return;
+        }
+        let collisions = this.collisions;
+        if (collisions === undefined) {
+            collisions = new TypeListCache();
+            this.collisions = collisions;
+        }
+        collisions.set(hash, reference.resolvedTypeArguments, undefined, 0, reference);
+    }
+}
+/**
+ * Fields that few types set, kept out of line in `Type.extra`, which is created on the first write
+ * of a value other than the field's default. A type then costs one slot for all of them. Each field
+ * is read and written through an accessor of the type class it belongs to, which returns the
+ * default while the type has no extra fields. Rare fields that hot paths read stay inline (the
+ * alias, construct signatures): a native accessor returns an owned reference, which costs reference
+ * counting on every read of a counted value.
+ */
+export class TypeExtra {
+    // StructuredType
+    objectTypeWithoutAbstractConstructSignatures;
+    // ObjectType
+    instantiations;
+    // TypeReference
+    node;
+    // UnionType
+    resolvedReducedType;
+    regularType;
+    origin;
+    keyPropertyName;
+    constituentMap;
+    constituentSet;
+    membershipTests;
+    // IntersectionType
+    uniqueLiteralFilledInstantiation;
+    constructor() {
+        this.objectTypeWithoutAbstractConstructSignatures = undefined;
+        this.instantiations = undefined;
+        this.node = undefined;
+        this.resolvedReducedType = undefined;
+        this.regularType = undefined;
+        this.origin = undefined;
+        this.keyPropertyName = '';
+        this.constituentMap = undefined;
+        this.constituentSet = undefined;
+        this.membershipTests = 0;
+        this.uniqueLiteralFilledInstantiation = undefined;
+    }
+}
+/** The extra fields of `t`, created if it has none yet. */
+export function typeExtra(t) {
+    let extra = t.extra;
+    if (extra === undefined) {
+        extra = new TypeExtra();
+        t.extra = extra;
+    }
+    return extra;
+}
+/**
+ * The base of every type. Narrow by `flags` (and `objectFlags` for object types), then cast to
+ * the subclass, as tsgo does with `AsUnionType()` etc.
+ */
+/**
+ * `TSC_TS_SIDE_STATE=1` (a test of the side tables): every type and signature keeps its lazily
+ * computed state in the checker's side tables (`ObjectFlags.SideState`, `SignatureFlags.SideState`).
+ */
+export const sideStateForAll = process.env.TSC_TS_SIDE_STATE === '1';
+/** `symbol`, with its id assigned (`getSymbolId`): every symbol tsc-ts's public API hands out has one. */
+function withId(symbol) {
+    if (symbol !== undefined)
+        getSymbolId(symbol);
+    return symbol;
+}
+export class Type {
+    flags;
+    objectFlags;
+    id;
+    symbol;
+    alias;
+    /** For types with a computed base constraint (type variables, structured types, …). */
+    resolvedBaseConstraint;
+    /** Rarely set fields; undefined while all of them have their defaults. */
+    extra;
+    constructor(flags, objectFlags, id, symbol) {
+        this.flags = flags;
+        this.objectFlags = sideStateForAll ? objectFlags | -2147483648 /* ObjectFlags.SideState */ : objectFlags;
+        this.id = id | 0;
+        this.symbol = symbol;
+        this.alias = undefined;
+        this.resolvedBaseConstraint = undefined;
+        this.extra = undefined;
+    }
+    // TypeScript 7's API (tsc-ts/api): the parts of a type, undefined or empty where its kind has none.
+    getSymbol() {
+        return withId(this.symbol);
+    }
+    getAliasSymbol() {
+        return withId(this.alias?.symbol);
+    }
+    getAliasTypeArguments() {
+        const alias = this.alias;
+        return alias === undefined ? emptyTypes : alias.typeArguments.slice();
+    }
+    /** The target of a type reference, index type or string mapping type. */
+    getTarget() {
+        if ((this.flags & 2097152 /* TypeFlags.Index */) !== 0)
+            return this.target;
+        if ((this.flags & 8388608 /* TypeFlags.StringMapping */) !== 0)
+            return this.target;
+        if (this.isTypeReference())
+            return this.target;
+        return undefined;
+    }
+    /** The members of a union or intersection type, or the types of a template literal type. */
+    getTypes() {
+        if ((this.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0)
+            return this.types.slice();
+        if ((this.flags & 402653184 /* TypeFlags.UnionOrIntersection */) !== 0)
+            return this.types.slice();
+        return emptyTypes;
+    }
+    getFreshType() {
+        return this instanceof LiteralType ? this.freshType : undefined;
+    }
+    getRegularType() {
+        return this instanceof LiteralType ? this.regularType : undefined;
+    }
+    getObjectType() {
+        return (this.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0 ? this.objectType : undefined;
+    }
+    getIndexType() {
+        return (this.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0 ? this.indexType : undefined;
+    }
+    getCheckType() {
+        return (this.flags & 67108864 /* TypeFlags.Conditional */) !== 0 ? this.checkType : undefined;
+    }
+    getExtendsType() {
+        return (this.flags & 67108864 /* TypeFlags.Conditional */) !== 0 ? this.extendsType : undefined;
+    }
+    getTrueType() {
+        if ((this.flags & 67108864 /* TypeFlags.Conditional */) === 0)
+            return undefined;
+        const conditional = this;
+        return conditional.checking?.trueTypeOf(conditional);
+    }
+    getFalseType() {
+        if ((this.flags & 67108864 /* TypeFlags.Conditional */) === 0)
+            return undefined;
+        const conditional = this;
+        return conditional.checking?.falseTypeOf(conditional);
+    }
+    /** The base type of a substitution type. */
+    getBaseType() {
+        return (this.flags & 16777216 /* TypeFlags.Substitution */) !== 0 ? this.baseType : undefined;
+    }
+    /** The constraint of a substitution type. */
+    getConstraint() {
+        return (this.flags & 16777216 /* TypeFlags.Substitution */) !== 0 ? this.constraint : undefined;
+    }
+    /** The type parameters of a class or interface type, outer and local, without its `this` type. */
+    getTypeParameters() {
+        return this.isClassOrInterface() ? this.typeParameters() : emptyTypes;
+    }
+    getOuterTypeParameters() {
+        return this.isClassOrInterface() ? this.outerTypeParameters() : emptyTypes;
+    }
+    getLocalTypeParameters() {
+        return this.isClassOrInterface() ? this.localTypeParameters() : emptyTypes;
+    }
+    /** The base types of a class or interface type, or undefined for any other type. */
+    getBaseTypes() {
+        if (!this.isClassOrInterface())
+            return undefined;
+        const declared = this;
+        return declared.checking === undefined ? emptyTypes : declared.checking.baseTypesOf(declared).slice();
+    }
+    isClassOrInterface() {
+        return (this.flags & 1048576 /* TypeFlags.Object */) !== 0 && (this.objectFlags & 3 /* ObjectFlags.ClassOrInterface */) !== 0;
+    }
+    isUnionType() {
+        return (this.flags & 134217728 /* TypeFlags.Union */) !== 0;
+    }
+    isIntersectionType() {
+        return (this.flags & 268435456 /* TypeFlags.Intersection */) !== 0;
+    }
+    isObjectType() {
+        return (this.flags & 1048576 /* TypeFlags.Object */) !== 0;
+    }
+    isIntrinsicType() {
+        return (this.flags & 393983 /* TypeFlags.Intrinsic */) !== 0;
+    }
+    /** Whether this is the error type: an intrinsic type named `error`. */
+    isErrorType() {
+        return this instanceof IntrinsicType && this.intrinsicName === 'error';
+    }
+    isLiteralType() {
+        return (this.flags & 15360 /* TypeFlags.Literal */) !== 0;
+    }
+    isStringLiteralType() {
+        return (this.flags & 1024 /* TypeFlags.StringLiteral */) !== 0;
+    }
+    isNumberLiteralType() {
+        return (this.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0;
+    }
+    isBigIntLiteralType() {
+        return (this.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0;
+    }
+    isBooleanLiteralType() {
+        return (this.flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0;
+    }
+    isTypeReference() {
+        return (this.flags & 1048576 /* TypeFlags.Object */) !== 0 && (this.objectFlags & 4 /* ObjectFlags.Reference */) !== 0;
+    }
+    isTupleType() {
+        return (this.flags & 1048576 /* TypeFlags.Object */) !== 0 && (this.objectFlags & 8 /* ObjectFlags.Tuple */) !== 0;
+    }
+    isIndexType() {
+        return (this.flags & 2097152 /* TypeFlags.Index */) !== 0;
+    }
+    isIndexedAccessType() {
+        return (this.flags & 33554432 /* TypeFlags.IndexedAccess */) !== 0;
+    }
+    isConditionalType() {
+        return (this.flags & 67108864 /* TypeFlags.Conditional */) !== 0;
+    }
+    isSubstitutionType() {
+        return (this.flags & 16777216 /* TypeFlags.Substitution */) !== 0;
+    }
+    isTemplateLiteralType() {
+        return (this.flags & 4194304 /* TypeFlags.TemplateLiteral */) !== 0;
+    }
+    isStringMappingType() {
+        return (this.flags & 8388608 /* TypeFlags.StringMapping */) !== 0;
+    }
+    isTypeParameter() {
+        return (this.flags & 524288 /* TypeFlags.TypeParameter */) !== 0;
+    }
+}
+export class IntrinsicType extends Type {
+    intrinsicName;
+    constructor(flags, objectFlags, id, intrinsicName) {
+        super(flags, objectFlags, id, undefined);
+        this.intrinsicName = intrinsicName;
+    }
+}
+/**
+ * A literal or enum member type. `value` is the string of string literals, the number of number
+ * literals, `true`/`false` for booleans, the decimal digits (with a leading `-`) of bigints, and
+ * unset for computed enum members.
+ */
+export class LiteralType extends Type {
+    stringValue;
+    numberValue;
+    /** Created on first use, except for `true` and `false`. */
+    freshType;
+    regularType;
+    constructor(flags, id, symbol, stringValue, numberValue) {
+        super(flags, 0 /* ObjectFlags.None */, id, symbol);
+        this.stringValue = stringValue;
+        this.numberValue = numberValue;
+        this.freshType = undefined;
+        this.regularType = this;
+    }
+    /** The value, as TypeScript 7's API gives it: a string, number, bigint or boolean. */
+    get value() {
+        if ((this.flags & 1024 /* TypeFlags.StringLiteral */) !== 0)
+            return this.stringValue;
+        if ((this.flags & 4096 /* TypeFlags.BigIntLiteral */) !== 0)
+            return BigInt(this.stringValue);
+        if ((this.flags & 8192 /* TypeFlags.BooleanLiteral */) !== 0)
+            return this.stringValue === 'true';
+        return this.numberValue;
+    }
+}
+export class UniqueESSymbolType extends Type {
+    name;
+    constructor(id, symbol, name) {
+        super(16384 /* TypeFlags.UniqueESSymbol */, 0 /* ObjectFlags.None */, id, symbol);
+        this.name = name;
+    }
+}
+/**
+ * The members table of a type, built when `members` is read (checker-members.ts): of an instantiated
+ * type whose member symbols are instantiated on demand (`PendingInstantiatedMembers`), where reading
+ * `properties` builds the properties too, as tsgo builds them when it resolves the members, and
+ * lookups by name instantiate only the member asked for; or of a type whose members are all
+ * properties (`PropertyMembers`), where lookups by name read the properties.
+ */
+export class PendingMembers {
+    /**
+     * Set when `properties` is built and the members table is not (`PropertyMembers`): the type's
+     * properties, which lookups by name then read.
+     */
+    materializedProperties = undefined;
+}
+/**
+ * The property names of instantiated types whose members tables are built on demand, shared by the
+ * instantiations of one source that have the same names in the same order: most instantiations of
+ * a class or interface have the members of their source and of the same bases.
+ */
+export class MemberNames {
+    /** The names of the properties, in order. */
+    names;
+    /** The index of each name in `names`. */
+    positions;
+    /** The indexes in `names` of the members table's names, in table order. */
+    tableOrder;
+    constructor(names, positions, tableOrder) {
+        this.names = names;
+        this.positions = positions;
+        this.tableOrder = tableOrder;
+    }
+}
+/** A type with members: object types, unions and intersections. */
+export class StructuredType extends Type {
+    membersValue;
+    propertiesValue;
+    /** Set while the member symbols of an instantiated type are not instantiated yet. */
+    pendingMembers;
+    callSignatures;
+    constructSignatures;
+    indexInfos;
+    constructor(flags, objectFlags, id, symbol) {
+        super(flags, objectFlags, id, symbol);
+        this.membersValue = undefined;
+        this.propertiesValue = emptySymbols;
+        this.pendingMembers = undefined;
+        this.callSignatures = emptySignatures;
+        this.constructSignatures = emptySignatures;
+        this.indexInfos = emptyIndexInfos;
+    }
+    get objectTypeWithoutAbstractConstructSignatures() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.objectTypeWithoutAbstractConstructSignatures : undefined;
+    }
+    set objectTypeWithoutAbstractConstructSignatures(t) {
+        if (t !== undefined || this.extra !== undefined)
+            typeExtra(this).objectTypeWithoutAbstractConstructSignatures = t;
+    }
+    get members() {
+        const pending = this.pendingMembers;
+        if (pending !== undefined)
+            pending.materializeTable(this);
+        return this.membersValue;
+    }
+    set members(members) {
+        this.membersValue = members;
+    }
+    get properties() {
+        const pending = this.pendingMembers;
+        if (pending !== undefined && pending.materializedProperties === undefined)
+            pending.materialize(this);
+        return this.propertiesValue;
+    }
+    set properties(properties) {
+        this.propertiesValue = properties;
+    }
+}
+export class ObjectType extends StructuredType {
+    /** The generic type this one instantiates. */
+    target;
+    mapper;
+    constructor(objectFlags, id, symbol) {
+        super(1048576 /* TypeFlags.Object */, objectFlags, id, symbol);
+        this.target = undefined;
+        this.mapper = undefined;
+    }
+    get instantiations() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.instantiations : undefined;
+    }
+    set instantiations(instantiations) {
+        if (instantiations !== undefined || this.extra !== undefined)
+            typeExtra(this).instantiations = instantiations;
+    }
+}
+/** An instantiation of a generic class, interface or tuple type. */
+export class TypeReference extends ObjectType {
+    resolvedTypeArguments;
+    constructor(objectFlags, id, symbol) {
+        super(objectFlags, id, symbol);
+        this.resolvedTypeArguments = undefined;
+    }
+    /** The type node of a deferred reference, else undefined. */
+    get node() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.node : undefined;
+    }
+    set node(node) {
+        if (node !== undefined || this.extra !== undefined)
+            typeExtra(this).node = node;
+    }
+}
+/** A class or interface; when generic, also the reference to itself instantiated with its own type parameters. */
+export class InterfaceType extends TypeReference {
+    /** Outer, then local type parameters, then the `this` type. */
+    allTypeParameters;
+    outerTypeParameterCount;
+    thisType;
+    baseTypesResolved;
+    declaredMembersResolved;
+    resolvedBaseConstructorType;
+    resolvedBaseTypes;
+    declaredMembers;
+    declaredCallSignatures;
+    declaredConstructSignatures;
+    declaredIndexInfos;
+    /** Positions of the declared members by name, for lazily instantiated members of instantiations. */
+    declaredMemberPositions;
+    /** The member states of the last pending instantiation of the type's members (`sharedStates`). */
+    lastMemberStates;
+    /** The property names of the last instantiation whose members table is built on demand. */
+    lastMemberNames;
+    /** The references to a generic class, interface or tuple type, by their type arguments. */
+    references;
+    /** The checker that created the type, for `getBaseTypes()`. */
+    checking;
+    constructor(objectFlags, id, symbol) {
+        super(objectFlags, id, symbol);
+        this.references = undefined;
+        this.checking = undefined;
+        this.declaredMemberPositions = undefined;
+        this.lastMemberStates = undefined;
+        this.lastMemberNames = undefined;
+        this.allTypeParameters = emptyTypes;
+        this.outerTypeParameterCount = 0;
+        this.thisType = undefined;
+        this.baseTypesResolved = false;
+        this.declaredMembersResolved = false;
+        this.resolvedBaseConstructorType = undefined;
+        this.resolvedBaseTypes = emptyTypes;
+        this.declaredMembers = undefined;
+        this.declaredCallSignatures = emptySignatures;
+        this.declaredConstructSignatures = emptySignatures;
+        this.declaredIndexInfos = emptyIndexInfos;
+    }
+    outerTypeParameters() {
+        return this.allTypeParameters.length === 0
+            ? emptyTypes
+            : this.allTypeParameters.slice(0, this.outerTypeParameterCount);
+    }
+    localTypeParameters() {
+        const all = this.allTypeParameters;
+        return all.length === 0 ? emptyTypes : all.slice(this.outerTypeParameterCount, all.length - 1);
+    }
+    typeParameters() {
+        const all = this.allTypeParameters;
+        return all.length === 0 ? emptyTypes : all.slice(0, all.length - 1);
+    }
+    /** `typeParameters().length`, without copying them. */
+    typeParameterCount() {
+        const count = this.allTypeParameters.length;
+        return count === 0 ? 0 : count - 1;
+    }
+}
+export class TupleElementInfo {
+    flags;
+    /** A NamedTupleMember or ParameterDeclaration, if labeled. */
+    labeledDeclaration;
+    constructor(flags, labeledDeclaration) {
+        this.flags = flags;
+        this.labeledDeclaration = labeledDeclaration;
+    }
+}
+export class TupleType extends InterfaceType {
+    elementInfos;
+    /** Required or variadic elements. */
+    minLength;
+    /** Leading required or optional elements. */
+    fixedLength;
+    combinedFlags;
+    readonly;
+    constructor(objectFlags, id) {
+        super(objectFlags, id, undefined);
+        this.elementInfos = [];
+        this.minLength = 0;
+        this.fixedLength = 0;
+        this.combinedFlags = 0 /* ElementFlags.None */;
+        this.readonly = false;
+    }
+    /** The flags of each element (TypeScript 7's API). */
+    get elementFlags() {
+        return this.elementInfos.map((info) => info.flags);
+    }
+}
+export class InstantiationExpressionType extends ObjectType {
+    node;
+    constructor(objectFlags, id, symbol) {
+        super(objectFlags, id, symbol);
+        this.node = undefined;
+    }
+}
+export class MappedType extends ObjectType {
+    declaration;
+    typeParameter;
+    constraintType;
+    nameType;
+    templateType;
+    modifiersType;
+    resolvedApparentType;
+    containsError;
+    constructor(objectFlags, id, symbol) {
+        super(objectFlags, id, symbol);
+        this.declaration = undefined;
+        this.typeParameter = undefined;
+        this.constraintType = undefined;
+        this.nameType = undefined;
+        this.templateType = undefined;
+        this.modifiersType = undefined;
+        this.resolvedApparentType = undefined;
+        this.containsError = false;
+    }
+}
+export class ReverseMappedType extends ObjectType {
+    source;
+    mappedType;
+    constraintType;
+    constructor(objectFlags, id) {
+        super(objectFlags, id, undefined);
+        this.source = undefined;
+        this.mappedType = undefined;
+        this.constraintType = undefined;
+    }
+}
+export class EvolvingArrayType extends ObjectType {
+    elementType;
+    finalArrayType;
+    constructor(objectFlags, id) {
+        super(objectFlags, id, undefined);
+        this.elementType = undefined;
+        this.finalArrayType = undefined;
+    }
+}
+export class UnionOrIntersectionType extends StructuredType {
+    types;
+    propertyCache;
+    propertyCacheWithoutFunctionPropertyAugment;
+    resolvedProperties;
+    constructor(flags, objectFlags, id, types) {
+        super(flags, objectFlags, id, undefined);
+        this.types = types;
+        this.propertyCache = undefined;
+        this.propertyCacheWithoutFunctionPropertyAugment = undefined;
+        this.resolvedProperties = undefined;
+    }
+}
+/** A union; all of its own fields are rarely set and live in `extra`. */
+export class UnionType extends UnionOrIntersectionType {
+    constructor(objectFlags, id, types) {
+        super(134217728 /* TypeFlags.Union */, objectFlags, id, types);
+    }
+    get resolvedReducedType() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.resolvedReducedType : undefined;
+    }
+    set resolvedReducedType(t) {
+        if (t !== undefined || this.extra !== undefined)
+            typeExtra(this).resolvedReducedType = t;
+    }
+    get regularType() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.regularType : undefined;
+    }
+    set regularType(t) {
+        if (t !== undefined || this.extra !== undefined)
+            typeExtra(this).regularType = t;
+    }
+    /** The denormalized union, intersection or index type the union came from. */
+    get origin() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.origin : undefined;
+    }
+    set origin(t) {
+        if (t !== undefined || this.extra !== undefined)
+            typeExtra(this).origin = t;
+    }
+    /** A property with a unique unit type in every object of the union; '' if not computed, '\0' if none. */
+    get keyPropertyName() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.keyPropertyName : '';
+    }
+    set keyPropertyName(name) {
+        if (name !== '' || this.extra !== undefined)
+            typeExtra(this).keyPropertyName = name;
+    }
+    get constituentMap() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.constituentMap : undefined;
+    }
+    set constituentMap(map) {
+        if (map !== undefined || this.extra !== undefined)
+            typeExtra(this).constituentMap = map;
+    }
+    /** The constituents of a large union, for membership tests; created on the second test. */
+    get constituentSet() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.constituentSet : undefined;
+    }
+    set constituentSet(set) {
+        if (set !== undefined || this.extra !== undefined)
+            typeExtra(this).constituentSet = set;
+    }
+    get membershipTests() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.membershipTests : 0;
+    }
+    set membershipTests(tests) {
+        if (tests !== 0 || this.extra !== undefined)
+            typeExtra(this).membershipTests = tests;
+    }
+}
+export class IntersectionType extends UnionOrIntersectionType {
+    resolvedApparentType;
+    constructor(objectFlags, id, types) {
+        super(268435456 /* TypeFlags.Intersection */, objectFlags, id, types);
+        this.resolvedApparentType = undefined;
+    }
+    get uniqueLiteralFilledInstantiation() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.uniqueLiteralFilledInstantiation : undefined;
+    }
+    set uniqueLiteralFilledInstantiation(t) {
+        if (t !== undefined || this.extra !== undefined)
+            typeExtra(this).uniqueLiteralFilledInstantiation = t;
+    }
+}
+export class TypeParameter extends Type {
+    constraint;
+    target;
+    mapper;
+    isThisType;
+    resolvedDefaultType;
+    constructor(id, symbol) {
+        super(524288 /* TypeFlags.TypeParameter */, 0 /* ObjectFlags.None */, id, symbol);
+        this.constraint = undefined;
+        this.target = undefined;
+        this.mapper = undefined;
+        this.isThisType = false;
+        this.resolvedDefaultType = undefined;
+    }
+}
+/** `keyof T`. */
+export class IndexType extends Type {
+    target;
+    indexFlags;
+    constructor(id, target, indexFlags) {
+        super(2097152 /* TypeFlags.Index */, 0 /* ObjectFlags.None */, id, undefined);
+        this.target = target;
+        this.indexFlags = indexFlags;
+    }
+}
+/** `T[K]`. */
+export class IndexedAccessType extends Type {
+    objectType;
+    indexType;
+    /** Only AccessFlags.Persistent. */
+    accessFlags;
+    constructor(id, objectType, indexType, accessFlags) {
+        super(33554432 /* TypeFlags.IndexedAccess */, 0 /* ObjectFlags.None */, id, undefined);
+        this.objectType = objectType;
+        this.indexType = indexType;
+        this.accessFlags = accessFlags;
+    }
+}
+export class TemplateLiteralType extends Type {
+    /** One longer than `types`. */
+    texts;
+    types;
+    constructor(id, texts, types) {
+        super(4194304 /* TypeFlags.TemplateLiteral */, 0 /* ObjectFlags.None */, id, undefined);
+        this.texts = texts;
+        this.types = types;
+    }
+}
+/** `Uppercase<T>` and friends. */
+export class StringMappingType extends Type {
+    target;
+    constructor(id, symbol, target) {
+        super(8388608 /* TypeFlags.StringMapping */, 0 /* ObjectFlags.None */, id, symbol);
+        this.target = target;
+    }
+}
+export class SubstitutionType extends Type {
+    baseType;
+    /** What the base type is known to satisfy. */
+    constraint;
+    constructor(id, baseType, constraint) {
+        super(16777216 /* TypeFlags.Substitution */, 0 /* ObjectFlags.None */, id, undefined);
+        this.baseType = baseType;
+        this.constraint = constraint;
+    }
+}
+export class ConditionalRoot {
+    node;
+    checkType;
+    extendsType;
+    isDistributive;
+    inferTypeParameters;
+    outerTypeParameters;
+    instantiations;
+    alias;
+    /**
+     * The type arguments of an extends type that is a reference to a class or interface; null for
+     * other extends types, undefined until computed.
+     */
+    referenceArgs;
+    constructor(node, checkType, extendsType, isDistributive, inferTypeParameters, outerTypeParameters, alias) {
+        this.node = node;
+        this.checkType = checkType;
+        this.extendsType = extendsType;
+        this.isDistributive = isDistributive;
+        this.inferTypeParameters = inferTypeParameters;
+        this.outerTypeParameters = outerTypeParameters;
+        this.instantiations = new TypeListCache();
+        this.alias = alias;
+        this.referenceArgs = undefined;
+    }
+}
+/** What each type argument of a conditional type's extends type is, for `isFalseForEveryInference`. */
+export class ReferenceArgs {
+    kinds;
+    /** The `infer` type parameter of each `ReferenceArgKind.Infer` type argument. */
+    inferTypeParameters;
+    constructor(kinds, inferTypeParameters) {
+        this.kinds = kinds;
+        this.inferTypeParameters = inferTypeParameters;
+    }
+}
+export class ConditionalType extends Type {
+    root;
+    checkType;
+    extendsType;
+    resolvedTrueType;
+    resolvedFalseType;
+    /** The true and false types, as one list (getBranchTypesFromConditionalType). */
+    resolvedBranchTypes;
+    resolvedInferredTrueType;
+    resolvedDefaultConstraint;
+    resolvedConstraintOfDistributive;
+    mapper;
+    combinedMapper;
+    /** The checker that created the type, for `getTrueType()` and `getFalseType()`. */
+    checking;
+    constructor(id, root, checkType, extendsType, mapper, combinedMapper) {
+        super(67108864 /* TypeFlags.Conditional */, 0 /* ObjectFlags.None */, id, undefined);
+        this.root = root;
+        this.checkType = checkType;
+        this.extendsType = extendsType;
+        this.resolvedTrueType = undefined;
+        this.resolvedFalseType = undefined;
+        this.resolvedBranchTypes = undefined;
+        this.resolvedInferredTrueType = undefined;
+        this.resolvedDefaultConstraint = undefined;
+        this.resolvedConstraintOfDistributive = undefined;
+        this.mapper = mapper;
+        this.combinedMapper = combinedMapper;
+        this.checking = undefined;
+    }
+}
+// ---- Signatures and index infos
+export class TypePredicate {
+    kind;
+    parameterIndex;
+    parameterName;
+    type;
+    constructor(kind, parameterName, parameterIndex, type) {
+        this.kind = kind;
+        this.parameterIndex = parameterIndex;
+        this.parameterName = parameterName;
+        this.type = type;
+    }
+}
+export class CompositeSignature {
+    /** False for an intersection. */
+    isUnion;
+    signatures;
+    constructor(isUnion, signatures) {
+        this.isUnion = isUnion;
+        this.signatures = signatures;
+    }
+}
+/**
+ * Fields that few signatures set, kept out of line in `Signature.extra` (see TypeExtra): the `this`
+ * parameter, composite signatures and the caches of derived signatures.
+ */
+export class SignatureExtra {
+    thisParameter;
+    isolatedSignatureType;
+    composite;
+    erasedSignatureCache;
+    canonicalSignatureCache;
+    baseSignatureCache;
+    optionalCallSignatureCache;
+    instantiations;
+    constructor() {
+        this.thisParameter = undefined;
+        this.isolatedSignatureType = undefined;
+        this.composite = undefined;
+        this.erasedSignatureCache = undefined;
+        this.canonicalSignatureCache = undefined;
+        this.baseSignatureCache = undefined;
+        this.optionalCallSignatureCache = undefined;
+        this.instantiations = undefined;
+    }
+}
+/** The extra fields of `s`, created if it has none yet. */
+export function signatureExtra(s) {
+    let extra = s.extra;
+    if (extra === undefined) {
+        extra = new SignatureExtra();
+        s.extra = extra;
+    }
+    return extra;
+}
+export class Signature {
+    id;
+    flags;
+    minArgumentCount;
+    /** -1 until computed. */
+    resolvedMinArgumentCount;
+    declaration;
+    typeParameters;
+    parameters;
+    resolvedReturnType;
+    resolvedTypePredicate;
+    target;
+    mapper;
+    /** Rarely set fields; undefined while all of them have their defaults. */
+    extra;
+    constructor(id, flags, declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount) {
+        this.id = id | 0;
+        this.flags = sideStateForAll ? flags | 512 /* SignatureFlags.SideState */ : flags;
+        this.minArgumentCount = minArgumentCount | 0;
+        this.resolvedMinArgumentCount = -1;
+        this.declaration = declaration;
+        this.typeParameters = typeParameters;
+        this.parameters = parameters;
+        this.resolvedReturnType = resolvedReturnType;
+        this.resolvedTypePredicate = resolvedTypePredicate;
+        this.target = undefined;
+        this.mapper = undefined;
+        this.extra = undefined;
+        if (thisParameter !== undefined)
+            signatureExtra(this).thisParameter = thisParameter;
+    }
+    get thisParameter() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.thisParameter : undefined;
+    }
+    set thisParameter(symbol) {
+        if (symbol !== undefined || this.extra !== undefined)
+            signatureExtra(this).thisParameter = symbol;
+    }
+    // TypeScript 7's API (tsc-ts/api).
+    getTypeParameters() {
+        return this.typeParameters.slice();
+    }
+    getParameters() {
+        for (const parameter of this.parameters)
+            getSymbolId(parameter);
+        return this.parameters.slice();
+    }
+    getThisParameter() {
+        return withId(this.thisParameter);
+    }
+    /** The signature this one was instantiated from. */
+    getTarget() {
+        return this.target;
+    }
+    get isolatedSignatureType() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.isolatedSignatureType : undefined;
+    }
+    set isolatedSignatureType(t) {
+        if (t !== undefined || this.extra !== undefined)
+            signatureExtra(this).isolatedSignatureType = t;
+    }
+    get composite() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.composite : undefined;
+    }
+    set composite(composite) {
+        if (composite !== undefined || this.extra !== undefined)
+            signatureExtra(this).composite = composite;
+    }
+    /** Caches of derived signatures. */
+    get erasedSignatureCache() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.erasedSignatureCache : undefined;
+    }
+    set erasedSignatureCache(s) {
+        if (s !== undefined || this.extra !== undefined)
+            signatureExtra(this).erasedSignatureCache = s;
+    }
+    get canonicalSignatureCache() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.canonicalSignatureCache : undefined;
+    }
+    set canonicalSignatureCache(s) {
+        if (s !== undefined || this.extra !== undefined)
+            signatureExtra(this).canonicalSignatureCache = s;
+    }
+    get baseSignatureCache() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.baseSignatureCache : undefined;
+    }
+    set baseSignatureCache(s) {
+        if (s !== undefined || this.extra !== undefined)
+            signatureExtra(this).baseSignatureCache = s;
+    }
+    get optionalCallSignatureCache() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.optionalCallSignatureCache : undefined;
+    }
+    set optionalCallSignatureCache(s) {
+        if (s !== undefined || this.extra !== undefined)
+            signatureExtra(this).optionalCallSignatureCache = s;
+    }
+    get instantiations() {
+        const extra = this.extra;
+        return extra !== undefined ? extra.instantiations : undefined;
+    }
+    set instantiations(instantiations) {
+        if (instantiations !== undefined || this.extra !== undefined)
+            signatureExtra(this).instantiations = instantiations;
+    }
+    hasRestParameter() {
+        return (this.flags & 1 /* SignatureFlags.HasRestParameter */) !== 0;
+    }
+}
+export class IndexInfo {
+    keyType;
+    valueType;
+    isReadonly;
+    /** The IndexSignatureDeclaration. */
+    declaration;
+    /** Elements with computed property names that make up the index signature. */
+    components;
+    indexSymbol;
+    constructor(keyType, valueType, isReadonly, declaration, components) {
+        this.keyType = keyType;
+        this.valueType = valueType;
+        this.isReadonly = isReadonly;
+        this.declaration = declaration;
+        this.components = components;
+        this.indexSymbol = undefined;
+    }
+    /** The value type (TypeScript 7's API). */
+    get type() {
+        return this.valueType;
+    }
+}
+// Shared empty lists; never mutated.
+export const emptyTypes = [];
+export const emptySymbols = [];
+export const emptySignatures = [];
+export const emptyIndexInfos = [];
+/** Maps type parameters to types. Subclasses replace tsgo's function mappers. */
+export class TypeMapper {
+    kind() {
+        return 0 /* TypeMapperKind.Unknown */;
+    }
+    /** Whether the mapper only maps a `this` type parameter. */
+    mapsThisOnly() {
+        return false;
+    }
+}
+function isThisTypeParameter(type) {
+    return (type.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && type.isThisType;
+}
+export class SimpleTypeMapper extends TypeMapper {
+    source;
+    target;
+    constructor(source, target) {
+        super();
+        this.source = source;
+        this.target = target;
+    }
+    map(type) {
+        return type === this.source ? this.target : type;
+    }
+    kind() {
+        return 1 /* TypeMapperKind.Simple */;
+    }
+    mapsThisOnly() {
+        return isThisTypeParameter(this.source);
+    }
+}
+export class ArrayTypeMapper extends TypeMapper {
+    sources;
+    targets;
+    constructor(sources, targets) {
+        super();
+        this.sources = sources;
+        this.targets = targets;
+    }
+    map(type) {
+        const sources = this.sources;
+        for (let i = 0; i < sources.length; i++)
+            if (type === sources[i])
+                return this.targets[i];
+        return type;
+    }
+    kind() {
+        return 2 /* TypeMapperKind.Array */;
+    }
+    mapsThisOnly() {
+        return this.sources.length === 1 && isThisTypeParameter(this.sources[0]);
+    }
+}
+/**
+ * The number of sources from which a mapper looks types up in an index. A tuple reference with thousands of
+ * elements maps one type parameter per element, and searching them all for each element was quadratic in the
+ * tuple's length.
+ */
+const indexedTypeMapperThreshold = 64;
+/** An ArrayTypeMapper that looks its sources up in an index, built on its first lookup. */
+export class IndexedArrayTypeMapper extends ArrayTypeMapper {
+    /** The index of each source's first occurrence. */
+    index = undefined;
+    /** The number of sources `index` was built from. */
+    indexedLength = 0;
+    map(type) {
+        const sources = this.sources;
+        let index = this.index;
+        if (index === undefined || this.indexedLength !== sources.length) {
+            index = new Map();
+            for (let i = 0; i < sources.length; i++)
+                if (!index.has(sources[i]))
+                    index.set(sources[i], i);
+            this.index = index;
+            this.indexedLength = sources.length;
+        }
+        const i = index.get(type);
+        return i !== undefined ? this.targets[i] : type;
+    }
+}
+/** Maps each of `sources` to one target. */
+export class ArrayToSingleTypeMapper extends TypeMapper {
+    sources;
+    target;
+    constructor(sources, target) {
+        super();
+        this.sources = sources;
+        this.target = target;
+    }
+    map(type) {
+        return this.sources.includes(type) ? this.target : type;
+    }
+    mapsThisOnly() {
+        return this.sources.length === 1 && isThisTypeParameter(this.sources[0]);
+    }
+}
+/** Applies `m1`, then `m2`. */
+export class MergedTypeMapper extends TypeMapper {
+    m1;
+    m2;
+    constructor(m1, m2) {
+        super();
+        this.m1 = m1;
+        this.m2 = m2;
+    }
+    map(type) {
+        return this.m2.map(this.m1.map(type));
+    }
+    kind() {
+        return 3 /* TypeMapperKind.Merged */;
+    }
+}
+export function newTypeMapper(sources, targets) {
+    if (sources.length === 1)
+        return new SimpleTypeMapper(sources[0], targets[0]);
+    return sources.length >= indexedTypeMapperThreshold
+        ? new IndexedArrayTypeMapper(sources, targets)
+        : new ArrayTypeMapper(sources, targets);
+}
+export function mergeTypeMappers(m1, m2) {
+    return m1 !== undefined ? new MergedTypeMapper(m1, m2) : m2;
+}
+export function prependTypeMapping(source, target, mapper) {
+    const simple = new SimpleTypeMapper(source, target);
+    return mapper === undefined ? simple : new MergedTypeMapper(simple, mapper);
+}
+export function appendTypeMapping(mapper, source, target) {
+    const simple = new SimpleTypeMapper(source, target);
+    return mapper === undefined ? simple : new MergedTypeMapper(mapper, simple);
+}
+// ---- Links
+/**
+ * What the checker caches per symbol and rarely sets. Common values (the type, target, mapper, name type
+ * and others) are columns of `Checker` instead; see link-tables.ts. The fields most links objects have
+ * are fields of this class; the others are in a RareSymbolLinks object, created on the first write of
+ * one of them, behind accessors.
+ */
+export class SymbolLinks {
+    /** Constituents of a deferred union/intersection property type. */
+    deferralParent;
+    deferralConstituents;
+    immediateTarget;
+    aliasTarget;
+    resolvedExports;
+    resolvedMembers;
+    declaredType;
+    /** The other links, created on first write. */
+    rareLinks;
+    functionOrConstructorChecked;
+    aliasReferenced;
+    constructor() {
+        this.deferralParent = undefined;
+        this.deferralConstituents = undefined;
+        this.functionOrConstructorChecked = false;
+        this.immediateTarget = undefined;
+        this.aliasTarget = undefined;
+        this.aliasReferenced = false;
+        this.resolvedExports = undefined;
+        this.resolvedMembers = undefined;
+        this.declaredType = undefined;
+        this.rareLinks = undefined;
+    }
+    rare() {
+        let rare = this.rareLinks;
+        if (rare === undefined) {
+            rare = new RareSymbolLinks();
+            this.rareLinks = rare;
+        }
+        return rare;
+    }
+    get writeType() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.writeType;
+    }
+    set writeType(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().writeType = value;
+    }
+    get deferralWriteConstituents() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.deferralWriteConstituents;
+    }
+    set deferralWriteConstituents(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().deferralWriteConstituents = value;
+    }
+    get typeOnlyDeclaration() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.typeOnlyDeclaration;
+    }
+    set typeOnlyDeclaration(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().typeOnlyDeclaration = value;
+    }
+    get typeOnlyExportStarMap() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.typeOnlyExportStarMap;
+    }
+    set typeOnlyExportStarMap(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().typeOnlyExportStarMap = value;
+    }
+    get exportsChecked() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.exportsChecked;
+    }
+    set exportsChecked(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().exportsChecked = value;
+    }
+    get lateSymbol() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.lateSymbol;
+    }
+    set lateSymbol(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().lateSymbol = value;
+    }
+    get typeParameters() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.typeParameters;
+    }
+    set typeParameters(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().typeParameters = value;
+    }
+    get instantiations() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.instantiations;
+    }
+    set instantiations(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().instantiations = value;
+    }
+    get interfaceChecked() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.interfaceChecked;
+    }
+    set interfaceChecked(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().interfaceChecked = value;
+    }
+    get indexSignaturesChecked() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.indexSignaturesChecked;
+    }
+    set indexSignaturesChecked(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().indexSignaturesChecked = value;
+    }
+    get typeParametersChecked() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.typeParametersChecked;
+    }
+    set typeParametersChecked(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().typeParametersChecked = value;
+    }
+    get enumChecked() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.enumChecked;
+    }
+    set enumChecked(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().enumChecked = value;
+    }
+    get variances() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.variances;
+    }
+    set variances(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().variances = value;
+    }
+    get lastAssignmentPos() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.lastAssignmentPos;
+    }
+    set lastAssignmentPos(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().lastAssignmentPos = value;
+    }
+    get hasDefiniteAssignment() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.hasDefiniteAssignment;
+    }
+    set hasDefiniteAssignment(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().hasDefiniteAssignment = value;
+    }
+    get isConstructorDeclaredProperty() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.isConstructorDeclaredProperty;
+    }
+    set isConstructorDeclaredProperty(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().isConstructorDeclaredProperty = value;
+    }
+    get thisAssignmentKind() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.thisAssignmentKind;
+    }
+    set thisAssignmentKind(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().thisAssignmentKind = value;
+    }
+    get thisAssignmentLocation() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.thisAssignmentLocation;
+    }
+    set thisAssignmentLocation(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().thisAssignmentLocation = value;
+    }
+    get reverseMappedPropertyType() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.reverseMappedPropertyType;
+    }
+    set reverseMappedPropertyType(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().reverseMappedPropertyType = value;
+    }
+    get reverseMappedMappedType() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.reverseMappedMappedType;
+    }
+    set reverseMappedMappedType(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().reverseMappedMappedType = value;
+    }
+    get reverseMappedConstraintType() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.reverseMappedConstraintType;
+    }
+    set reverseMappedConstraintType(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().reverseMappedConstraintType = value;
+    }
+}
+/** The links of a symbol that few symbols have (SymbolLinks). */
+export class RareSymbolLinks {
+    // Values
+    writeType;
+    deferralWriteConstituents;
+    typeOnlyDeclaration;
+    /** Exports reached only through `export type *`, by name. */
+    typeOnlyExportStarMap;
+    exportsChecked;
+    lateSymbol;
+    /** Type parameters of a type alias. */
+    typeParameters;
+    /** Instantiations of a generic type alias. */
+    instantiations;
+    interfaceChecked;
+    indexSignaturesChecked;
+    typeParametersChecked;
+    enumChecked;
+    variances;
+    // Assignment tracking
+    lastAssignmentPos;
+    hasDefiniteAssignment;
+    isConstructorDeclaredProperty;
+    // JavaScript `this.x` assignment declarations
+    /** A `ThisAssignmentKind` plus one; zero until computed. */
+    thisAssignmentKind;
+    thisAssignmentLocation;
+    // Reverse mapped properties
+    reverseMappedPropertyType;
+    reverseMappedMappedType;
+    reverseMappedConstraintType;
+    constructor() {
+        this.writeType = undefined;
+        this.deferralWriteConstituents = undefined;
+        this.typeOnlyDeclaration = undefined;
+        this.typeOnlyExportStarMap = undefined;
+        this.exportsChecked = false;
+        this.lateSymbol = undefined;
+        this.typeParameters = undefined;
+        this.instantiations = undefined;
+        this.interfaceChecked = false;
+        this.indexSignaturesChecked = false;
+        this.typeParametersChecked = false;
+        this.enumChecked = false;
+        this.variances = undefined;
+        this.lastAssignmentPos = 0;
+        this.hasDefiniteAssignment = false;
+        this.isConstructorDeclaredProperty = false;
+        this.thisAssignmentKind = 0;
+        this.thisAssignmentLocation = undefined;
+        this.reverseMappedPropertyType = undefined;
+        this.reverseMappedMappedType = undefined;
+        this.reverseMappedConstraintType = undefined;
+    }
+}
+/**
+ * What the checker caches per node and rarely sets. The resolved symbol, type and signature are columns of
+ * `Checker` instead; see link-tables.ts. As in SymbolLinks, the fields few links objects have are in a
+ * RareNodeLinks object behind accessors.
+ */
+export class NodeLinks {
+    /** Outer type parameters of an anonymous object type node. */
+    outerTypeParameters;
+    effectsSignature;
+    /** Type of an assertion's operand. */
+    assertionExpressionType;
+    /** The other links, created on first write. */
+    rareLinks;
+    flags;
+    constructor() {
+        this.flags = 0 /* NodeCheckFlags.None */;
+        this.outerTypeParameters = undefined;
+        this.effectsSignature = undefined;
+        this.assertionExpressionType = undefined;
+        this.rareLinks = undefined;
+    }
+    rare() {
+        let rare = this.rareLinks;
+        if (rare === undefined) {
+            rare = new RareNodeLinks();
+            this.rareLinks = rare;
+        }
+        return rare;
+    }
+    get contextFreeType() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.contextFreeType;
+    }
+    set contextFreeType(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().contextFreeType = value;
+    }
+    get enumStringValue() {
+        const rare = this.rareLinks;
+        return rare === undefined ? '' : rare.enumStringValue;
+    }
+    set enumStringValue(value) {
+        if (value === '' && this.rareLinks === undefined)
+            return;
+        this.rare().enumStringValue = value;
+    }
+    get enumNumberValue() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.enumNumberValue;
+    }
+    set enumNumberValue(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().enumNumberValue = value;
+    }
+    get enumValueKind() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.enumValueKind;
+    }
+    set enumValueKind(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().enumValueKind = value;
+    }
+    get enumValueFlags() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.enumValueFlags;
+    }
+    set enumValueFlags(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().enumValueFlags = value;
+    }
+    get hasReportedStatementInAmbientContext() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.hasReportedStatementInAmbientContext;
+    }
+    set hasReportedStatementInAmbientContext(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().hasReportedStatementInAmbientContext = value;
+    }
+    get declarationRequiresScopeChange() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.declarationRequiresScopeChange;
+    }
+    set declarationRequiresScopeChange(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().declarationRequiresScopeChange = value;
+    }
+    get typeChecked() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.typeChecked;
+    }
+    set typeChecked(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().typeChecked = value;
+    }
+    get deferredNodes() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.deferredNodes;
+    }
+    set deferredNodes(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().deferredNodes = value;
+    }
+    get switchTypes() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.switchTypes;
+    }
+    set switchTypes(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().switchTypes = value;
+    }
+    get switchWitnesses() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.switchWitnesses;
+    }
+    set switchWitnesses(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().switchWitnesses = value;
+    }
+    get switchWitnessesValid() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.switchWitnessesValid;
+    }
+    set switchWitnessesValid(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().switchWitnessesValid = value;
+    }
+    get exhaustiveState() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.exhaustiveState;
+    }
+    set exhaustiveState(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().exhaustiveState = value;
+    }
+    get decoratorSignature() {
+        const rare = this.rareLinks;
+        return rare === undefined ? undefined : rare.decoratorSignature;
+    }
+    set decoratorSignature(value) {
+        if (value === undefined && this.rareLinks === undefined)
+            return;
+        this.rare().decoratorSignature = value;
+    }
+    get containsArgumentsReference() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.containsArgumentsReference;
+    }
+    set containsArgumentsReference(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().containsArgumentsReference = value;
+    }
+    get mentionsArguments() {
+        const rare = this.rareLinks;
+        return rare === undefined ? 0 : rare.mentionsArguments;
+    }
+    set mentionsArguments(value) {
+        if (value === 0 && this.rareLinks === undefined)
+            return;
+        this.rare().mentionsArguments = value;
+    }
+}
+/** The links of a node that few nodes have (NodeLinks). */
+export class RareNodeLinks {
+    /** Context-free type of an expression. */
+    contextFreeType;
+    /** Enum member value: a string, or a number when `enumValueIsNumber`. */
+    enumStringValue;
+    enumNumberValue;
+    enumValueKind;
+    /** EvaluatedFlags of the enum member value. */
+    enumValueFlags;
+    hasReportedStatementInAmbientContext;
+    declarationRequiresScopeChange;
+    /** For source files: whether the file has been checked, and its nodes waiting for a deferred check. */
+    typeChecked;
+    deferredNodes;
+    /** Case clause types of a switch statement. */
+    switchTypes;
+    /** `typeof` case texts of a switch statement; '' for default and duplicates. */
+    switchWitnesses;
+    switchWitnessesValid;
+    /** 0 unknown, 1 computing, 2 not exhaustive, 3 exhaustive. */
+    exhaustiveState;
+    /** The signature the runtime calls a decorator of this declaration with. */
+    decoratorSignature;
+    /** Whether a function body references `arguments`: 0 until computed, 1 for no, 2 for yes. */
+    containsArgumentsReference;
+    /** For source files: whether the file has an identifier `arguments`: 0 until computed, 1 for no, 2 for yes. */
+    mentionsArguments;
+    constructor() {
+        this.contextFreeType = undefined;
+        this.enumStringValue = '';
+        this.enumNumberValue = 0;
+        this.enumValueKind = 0;
+        this.enumValueFlags = 0;
+        this.hasReportedStatementInAmbientContext = false;
+        this.declarationRequiresScopeChange = 0;
+        this.typeChecked = false;
+        this.deferredNodes = undefined;
+        this.switchTypes = undefined;
+        this.switchWitnesses = undefined;
+        this.switchWitnessesValid = false;
+        this.exhaustiveState = 0;
+        this.decoratorSignature = undefined;
+        this.containsArgumentsReference = 0;
+        this.mentionsArguments = 0;
+    }
+}