tsc-ts 0.0.9 → 0.1.0

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

@@ -517,6 +517,52 @@ export class MemberNames {
         this.tableOrder = tableOrder;
     }
 }
+/**
+ * The properties of the instantiations of one source without base types, as `getNamedMembers` orders them
+ * for `container`: the source positions of the named members in that order, and their names
+ * (`PropertyMembers`). The other members are skipped, so the named members are all of an instantiation's table.
+ */
+export class NamedMemberOrder {
+    container;
+    positions;
+    names;
+    constructor(container, positions, names) {
+        this.container = container;
+        this.positions = positions;
+        this.names = names;
+    }
+}
+/**
+ * What the pending instantiations of a declared members table share whatever their mapper: the members in
+ * table order, which of them are named (the others are skipped), and the members whose resolved type keeps
+ * them under any instantiation (`keepsSymbolTypeUnderInstantiation`), found so far.
+ */
+export class DeclaredMemberPlan {
+    table;
+    /**
+     * Whether instantiations build the table eagerly: tsgo's table wouldn't be keyed by symbol names, or an
+     * own member could be replaced by an inherited one. The other fields are then incomplete.
+     */
+    eager;
+    members;
+    /** 1 for a named member, 0 for a skipped one, by position. */
+    named;
+    /** Bits by position: the member's type keeps it under instantiation. Set when found, never cleared. */
+    keptByType;
+    hasOwnMembers;
+    hasRequiredOwnMembers;
+    constructor(table, eager, members, named, hasOwnMembers, hasRequiredOwnMembers) {
+        this.table = table;
+        this.eager = eager;
+        this.members = members;
+        this.named = named;
+        this.keptByType = [];
+        for (let i = 0; i < members.length; i += 32)
+            this.keptByType.push(0);
+        this.hasOwnMembers = hasOwnMembers;
+        this.hasRequiredOwnMembers = hasRequiredOwnMembers;
+    }
+}
 /** A type with members: object types, unions and intersections. */
 export class StructuredType extends Type {
     membersValue;
@@ -613,6 +659,10 @@ export class InterfaceType extends TypeReference {
     declaredIndexInfos;
     /** Positions of the declared members by name, for lazily instantiated members of instantiations. */
     declaredMemberPositions;
+    /** The property order of instantiations (`NamedMemberOrder`); null where it can't be cached. */
+    namedMemberOrder;
+    /** What pending instantiations of the declared members share (`DeclaredMemberPlan`). */
+    declaredMemberPlan;
     /** 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. */
@@ -626,6 +676,8 @@ export class InterfaceType extends TypeReference {
         this.references = undefined;
         this.checking = undefined;
         this.declaredMemberPositions = undefined;
+        this.namedMemberOrder = undefined;
+        this.declaredMemberPlan = undefined;
         this.lastMemberStates = undefined;
         this.lastMemberNames = undefined;
         this.allTypeParameters = emptyTypes;
@@ -863,16 +915,39 @@ export class TypeParameter extends Type {
     target;
     mapper;
     isThisType;
+    /**
+     * A type parameter as referenced inside a distributive conditional type on it, which stands for each
+     * constituent in turn; its constraint is the type parameter it was made from (`getDistributedTypeParameter`).
+     */
+    isDistributed;
     resolvedDefaultType;
+    /** The distributed form of this type parameter, made on first use. */
+    distributedType;
     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.isDistributed = false;
         this.resolvedDefaultType = undefined;
+        this.distributedType = undefined;
     }
 }
+/** Whether `t` is the distributed form of a type parameter. */
+export function isDistributedTypeParameter(t) {
+    return (t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && t.isDistributed;
+}
+/** The type parameter a distributed type parameter was made from; other types as they are. */
+export function getNonDistributedTypeParameter(t) {
+    return (t.flags & 524288 /* TypeFlags.TypeParameter */) !== 0 && t.isDistributed
+        ? t.constraint
+        : t;
+}
+/** What `mapper` maps `t` to, a distributed type parameter as the type parameter it was made from. */
+export function getMappedType(t, mapper) {
+    return mapper.map(getNonDistributedTypeParameter(t));
+}
 /** `keyof T`. */
 export class IndexType extends Type {
     target;
@@ -1189,8 +1264,15 @@ export const emptyTypes = [];
 export const emptySymbols = [];
 export const emptySignatures = [];
 export const emptyIndexInfos = [];
+/** The id of the next mapper this thread creates. */
+let nextTypeMapperId = 0;
 /** Maps type parameters to types. Subclasses replace tsgo's function mappers. */
 export class TypeMapper {
+    /**
+     * A number for the mapper, unique among the mappers this thread creates (until it wraps at 2^31), so the
+     * stack of active mappers can be searched by id instead of by reference.
+     */
+    id = (nextTypeMapperId = (nextTypeMapperId + 1) | 0);
     kind() {
         return 0 /* TypeMapperKind.Unknown */;
     }
@@ -1359,11 +1441,11 @@ 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);
+    const simple = new SimpleTypeMapper(getNonDistributedTypeParameter(source), target);
     return mapper === undefined ? simple : new MergedTypeMapper(simple, mapper);
 }
 export function appendTypeMapping(mapper, source, target) {
-    const simple = new SimpleTypeMapper(source, target);
+    const simple = new SimpleTypeMapper(getNonDistributedTypeParameter(source), target);
     return mapper === undefined ? simple : new MergedTypeMapper(mapper, simple);
 }
 // ---- Links
@@ -1514,6 +1596,15 @@ export class SymbolLinks {
             return;
         this.rare().enumChecked = value;
     }
+    get mergedExportsChecked() {
+        const rare = this.rareLinks;
+        return rare === undefined ? false : rare.mergedExportsChecked;
+    }
+    set mergedExportsChecked(value) {
+        if (value === false && this.rareLinks === undefined)
+            return;
+        this.rare().mergedExportsChecked = value;
+    }
     get variances() {
         const rare = this.rareLinks;
         return rare === undefined ? undefined : rare.variances;
@@ -1614,6 +1705,7 @@ export class RareSymbolLinks {
     indexSignaturesChecked;
     typeParametersChecked;
     enumChecked;
+    mergedExportsChecked;
     variances;
     // Assignment tracking
     lastAssignmentPos;
@@ -1640,6 +1732,7 @@ export class RareSymbolLinks {
         this.indexSignaturesChecked = false;
         this.typeParametersChecked = false;
         this.enumChecked = false;
+        this.mergedExportsChecked = false;
         this.variances = undefined;
         this.lastAssignmentPos = 0;
         this.hasDefiniteAssignment = false;
@@ -1872,3 +1965,29 @@ export class RareNodeLinks {
         this.mentionsArguments = 0;
     }
 }
+/** A conditional type made as a member of a distribution: the instantiation's key, and the constituent it is for. */
+export class DistributedConditional {
+    typeArguments;
+    alias;
+    tag;
+    constituent;
+    constructor(typeArguments, alias, tag, constituent) {
+        this.typeArguments = typeArguments;
+        this.alias = alias;
+        this.tag = tag;
+        this.constituent = constituent;
+    }
+}
+/** The instantiation of a conditional type whose result is a conditional type: its root and key. */
+export class ConditionalResultKey {
+    root;
+    typeArguments;
+    alias;
+    tag;
+    constructor(root, typeArguments, alias, tag) {
+        this.root = root;
+        this.typeArguments = typeArguments;
+        this.alias = alias;
+        this.tag = tag;
+    }
+}