tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker-literals.d.ts

@@ -0,0 +1,6 @@
+import type { Checker } from './checker.js';
+import { type Symbol } from './symbol.js';
+import { type Type, TypeFlags } from './checker-types.js';
+/** The non-fresh form of an object literal type, with nested object literals regular too. */
+export declare function getRegularTypeOfObjectLiteral(c: Checker, t: Type): Type;
+export declare function getLiteralTypeFromPropertyForRelations(c: Checker, prop: Symbol, include: TypeFlags, includeNonPublic: boolean): Type;

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

@@ -0,0 +1,43 @@
+import { copyDeclarations, getSymbolId } from './symbol.js';
+import { cachedTypeKey } from './checker-types.js';
+import { createAnonymousType } from './checker-type-factory.js';
+import { getPropertiesOfObjectType, resolveStructuredTypeMembers } from './checker-members.js';
+import { getTypeOfSymbol } from './checker-symbol-types.js';
+import { getLiteralTypeFromProperty } from './checker-type-operators.js';
+/** The non-fresh form of an object literal type, with nested object literals regular too. */
+export function getRegularTypeOfObjectLiteral(c, t) {
+    if ((t.objectFlags & 128 /* ObjectFlags.ObjectLiteral */) === 0 ||
+        (t.objectFlags & 8192 /* ObjectFlags.FreshLiteral */) === 0 ||
+        (t.flags & 1048576 /* TypeFlags.Object */) === 0)
+        return t;
+    const key = cachedTypeKey(14 /* CachedTypeKind.RegularObjectLiteral */, t.id);
+    const cached = c.cachedTypesById.get(key);
+    if (cached !== undefined)
+        return cached;
+    const resolved = resolveStructuredTypeMembers(c, t);
+    const members = new Map();
+    for (const prop of getPropertiesOfObjectType(c, t)) {
+        const original = getTypeOfSymbol(c, prop);
+        const updated = getRegularTypeOfObjectLiteral(c, original);
+        members.set(prop.name, updated === original ? prop : createSymbolWithTypeLocal(c, prop, updated));
+    }
+    const regular = createAnonymousType(c, t.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.indexInfos);
+    regular.flags = t.flags;
+    regular.objectFlags |= t.objectFlags & ~(8192 /* ObjectFlags.FreshLiteral */ | -2147483648 /* ObjectFlags.SideState */);
+    c.cachedTypesById.set(key, regular);
+    return regular;
+}
+function createSymbolWithTypeLocal(c, source, t) {
+    const symbol = c.newSymbolWithCheckFlags(source.flags, source.name, source.checkFlags & 8 /* CheckFlags.Readonly */);
+    copyDeclarations(symbol, source);
+    symbol.parent = source.parent;
+    symbol.valueDeclaration = source.valueDeclaration;
+    const id = getSymbolId(symbol);
+    c.symbolTypes.set(id, t);
+    c.symbolTargets.set(id, source);
+    c.symbolNameTypes.set(id, c.symbolNameTypes.get(getSymbolId(source)));
+    return symbol;
+}
+export function getLiteralTypeFromPropertyForRelations(c, prop, include, includeNonPublic) {
+    return getLiteralTypeFromProperty(c, prop, include, includeNonPublic);
+}

package/dist/api/compiler/checker-members.d.ts

@@ -0,0 +1,200 @@
+import type { Node } from './ast.js';
+import { ModifierFlags } from './ast.js';
+import type { Checker } from './checker.js';
+import { IndexInfo, type InterfaceType, MemberNames, ObjectFlags, type Signature, SignatureKind, type StructuredType, type Type, type TypeMapper, type UnionOrIntersectionType, PendingMembers } from './checker-types.js';
+import { getUnionTypeEx, mapType } from './checker-type-factory.js';
+import { getLateBoundSymbol, getSymbolOfDeclaration } from './checker-symbols.js';
+import { instantiateTypes } from './instantiation.js';
+import { type RecursionId } from './relations.js';
+import { createSignatureInstantiation, getReturnTypeOfSignature } from './checker-signatures.js';
+import { type Symbol, type SymbolTable } from './symbol.js';
+/**
+ * `t` with its members resolved. The test is small enough to inline into callers, so a resolved
+ * type (almost every call) costs no call; the resolution itself is out of line.
+ */
+export declare function resolveStructuredTypeMembers(c: Checker, t: Type): StructuredType;
+/**
+ * The object that holds the resolved members of `t`: `t` itself, or for a type with side state
+ * (`ObjectFlags.SideState`) the checker's holder of its state (`sideOf`). Resolving the members of
+ * `t` writes them there; `t` keeps its identity and is never written.
+ */
+export declare function membersHolder(c: Checker, t: Type): StructuredType;
+/** The `objectFlags` of `t` that resolving its members sets (MembersResolved, UnresolvedMembers). */
+export declare function memberResolutionFlags(c: Checker, t: Type): ObjectFlags;
+declare const enum MemberState {
+    Skipped = 0,
+    Instantiated = 1,
+    Kept = 3
+}
+export declare class PendingInstantiatedMembers extends PendingMembers {
+    readonly c: Checker;
+    /** References: the declared members of the class or interface, by name. */
+    readonly sourceTable: SymbolTable | undefined;
+    /** Anonymous type instantiations: the properties of the target, in order. */
+    readonly sourceList: Symbol[] | undefined;
+    readonly mapper: TypeMapper;
+    /** MemberState of each member of the source, in order, 16 to a word. */
+    readonly states: number[];
+    /** Position of each member of the source by name (shared by all instantiations of the source). */
+    readonly positions: Map<string, number>;
+    /**
+     * What a reference inherits, per base type as far as resolution has come (`baseCount` bases): a
+     * base whose own pending table is complete (its properties are read on demand), or else the base's
+     * properties as read when tsgo reads them. Most types have one base: the first is kept in
+     * `firstBase` or `firstBaseProperties`, the others in `otherBases` or `otherBaseProperties`.
+     */
+    baseCount: number;
+    firstBase: StructuredType | undefined;
+    firstBaseProperties: Symbol[] | undefined;
+    otherBases: (StructuredType | undefined)[];
+    otherBaseProperties: (Symbol[] | undefined)[];
+    /** Whether the type has base types (tsgo copies the instantiated table into a new one then). */
+    hasBases: boolean;
+    /** While the base types are resolved: `properties` holds the own members only, as in tsgo. */
+    resolving: boolean;
+    /** Members instantiated by name lookups so far. */
+    instantiated: Map<string, Symbol> | undefined;
+    /** References: the holder of the declared members of the class or interface. */
+    owner: InterfaceType | undefined;
+    /** Whether the instantiated table has an own member, and one that isn't optional. */
+    readonly hasOwnMembers: boolean;
+    readonly hasRequiredOwnMembers: boolean;
+    constructor(c: Checker, sourceTable: SymbolTable | undefined, sourceList: Symbol[] | undefined, mapper: TypeMapper, states: number[], positions: Map<string, number>, hasOwnMembers: boolean, hasRequiredOwnMembers: boolean);
+    /** Records the next base: `base` where its pending table is complete, else its `properties`. */
+    addBase(base: StructuredType | undefined, properties: Symbol[] | undefined): void;
+    /** The base at `index` where its pending table is complete (`addBase`), else undefined. */
+    private baseAt;
+    /** The properties the base at `index` adds. */
+    private inheritedProperties;
+    state(position: number): MemberState;
+    /** The member symbol at `position` of the source, instantiated as tsgo would have. */
+    memberAt(position: number, source: Symbol): Symbol;
+    /** The own member `name` as in tsgo's instantiated table, or undefined. */
+    ownMember(name: string): Symbol | undefined;
+    get(name: string): Symbol | undefined;
+    /** The table of own members, as instantiateSymbolTable or createInstantiatedSymbolTable builds it. */
+    ownTable(): SymbolTable;
+    materialize(t: StructuredType): void;
+    /**
+     * After `materialize`: drops `members`, the table, where every member of it is a property. The
+     * table's names are then the names of the properties, so lookups by name read the properties by
+     * the positions of their names, and `materializeTable` builds the table again from them. The
+     * names come from the last instantiation of the same source, where they are the same.
+     */
+    private keepTableOnDemand;
+    materializeTable(t: StructuredType): void;
+}
+/**
+ * The members of a type whose members table holds only its properties, in the order of the
+ * properties or of `names.tableOrder`: lookups by name read the properties, by the positions of
+ * their names in `names` (`MemberNames`), or by comparing the names of a few properties
+ * (`scannedPropertiesLimit`) without `names`. Reading `members` builds the table.
+ */
+export declare class PropertyMembers extends PendingMembers {
+    readonly names: MemberNames | undefined;
+    constructor(properties: Symbol[], names: MemberNames | undefined);
+    materialize(_t: StructuredType): void;
+    materializeTable(t: StructuredType): void;
+    get(name: string): Symbol | undefined;
+}
+/** The most properties of an object literal's table that `keepPropertiesOnly` drops: literals are looked up often. */
+export declare const scannedLiteralPropertiesLimit = 4;
+/**
+ * After `setStructuredTypeMembers(c, t, members, ...)`: drops `members` where it holds only the
+ * type's properties, at most `limit` of them (`PropertyMembers`).
+ */
+export declare function keepPropertiesOnly(c: Checker, t: StructuredType, members: SymbolTable, limit?: number): void;
+/** `t.members?.get(name)` of a type whose members are resolved, without building a pending table. */
+export declare function getResolvedMember(t: StructuredType, name: string): Symbol | undefined;
+/** `t.properties.length !== 0` of a type whose members are resolved, without building a pending table. */
+export declare function hasResolvedProperties(t: StructuredType): boolean;
+/** `getPropertiesOfType(c, t).length !== 0`, without building a pending table. */
+export declare function hasPropertiesOfType(c: Checker, t: Type): boolean;
+/**
+ * `t.properties.every(p => p is optional)` of a type whose members are resolved and that has
+ * properties, without building a pending table where its own members decide.
+ */
+export declare function resolvedPropertiesAreOptional(t: StructuredType): boolean;
+export declare function findIndexInfo(indexInfos: readonly IndexInfo[], keyType: Type): IndexInfo | undefined;
+/** Resolves the declared members of `t`; returns the object that holds them (`sideOf`). */
+export declare function resolveDeclaredMembers(c: Checker, t: InterfaceType): InterfaceType;
+export declare function getIndexSymbol(c: Checker, symbol: Symbol): Symbol | undefined;
+export declare function getIndexInfosOfSymbol(c: Checker, symbol: Symbol): IndexInfo[];
+export declare function addInheritedMembers(symbols: SymbolTable, baseSymbols: readonly Symbol[]): void;
+export declare function instantiateSymbolTable(c: Checker, symbols: SymbolTable | undefined, mapper: TypeMapper): SymbolTable | undefined;
+export declare function isNamedMember(c: Checker, symbol: Symbol, id: string): boolean;
+/**
+ * The signatures present in every constituent: generic ones must match exactly; others may have
+ * extra optional parameters and differing return types, which are unioned.
+ */
+export declare function getUnionSignatures(c: Checker, signatureLists: Signature[][]): Signature[];
+export declare function findMatchingSignature(c: Checker, signatureList: readonly Signature[], signature: Signature, partialMatch: boolean, ignoreThisTypes: boolean, ignoreReturnTypes: boolean): Signature | undefined;
+export declare function compareTypeParametersIdentical(c: Checker, sourceParams: Type[], targetParams: Type[]): boolean;
+export declare function combineUnionOrIntersectionMemberSignatures(c: Checker, left: Signature, right: Signature, isUnion: boolean): Signature;
+export declare function getUnionIndexInfos(c: Checker, types: readonly Type[]): IndexInfo[];
+export declare function appendIndexInfo(c: Checker, indexInfos: IndexInfo[], newInfo: IndexInfo, union: boolean): IndexInfo[];
+export declare function getPropertiesOfType(c: Checker, t: Type): Symbol[];
+export declare function getPropertiesOfObjectType(c: Checker, t: Type): Symbol[];
+export declare function getPropertiesOfUnionOrIntersectionType(c: Checker, t: UnionOrIntersectionType): Symbol[];
+export declare function getPropertyOfType(c: Checker, t: Type, name: string): Symbol | undefined;
+/**
+ * The property `name` of `t`: synthesizes union and intersection properties, uses apparent types of
+ * primitives and type parameters, and falls back to Object and Function members.
+ */
+export declare function getPropertyOfTypeEx(c: Checker, t: Type, name: string, skipObjectFunctionPropertyAugment: boolean, includeTypeOnlyMembers: boolean): Symbol | undefined;
+export declare function getPropertyOfObjectType(c: Checker, t: Type, name: string): Symbol | undefined;
+export declare function getTypeOfPropertyOfType(c: Checker, t: Type, name: string): Type | undefined;
+export declare function getPropertyOfUnionOrIntersectionType(c: Checker, t: UnionOrIntersectionType, name: string, skipObjectFunctionPropertyAugment: boolean): Symbol | undefined;
+/**
+ * The (possibly partial) property `name` of a union or intersection, cached on the type.
+ *
+ * Non-partial results without the Object/Function augment also serve lookups with it (tsgo copies
+ * them into the augmented cache unless it already has the name). The augmented cache keeps only
+ * its own results and a miss there falls back to the other cache, which answers exactly what the
+ * copy would have: a name is in the augmented cache whenever a non-partial copy was skipped. This
+ * keeps intersections, which resolve every property without the augment, from holding each
+ * property twice.
+ */
+export declare function getUnionOrIntersectionProperty(c: Checker, t: UnionOrIntersectionType, name: string, skipObjectFunctionPropertyAugment: boolean): Symbol | undefined;
+export declare function getDeclarationModifierFlagsFromSymbol(c: Checker, s: Symbol, isWrite: boolean): ModifierFlags;
+export declare function createUnionOrIntersectionProperty(c: Checker, containingType: UnionOrIntersectionType, name: string, skipObjectFunctionPropertyAugment: boolean): Symbol | undefined;
+export declare function isObjectLiteralType(t: Type): boolean;
+export declare function getTargetSymbol(c: Checker, s: Symbol): Symbol;
+export declare function isPrototypeProperty(symbol: Symbol): boolean;
+export declare function createSymbolWithType(c: Checker, source: Symbol, t: Type | undefined): Symbol;
+export declare function getSignaturesOfType(c: Checker, t: Type, kind: SignatureKind): Signature[];
+export declare function getSignaturesOfStructuredType(c: Checker, t: Type, kind: SignatureKind): Signature[];
+export declare function getIndexInfosOfType(c: Checker, t: Type): IndexInfo[];
+export declare function getIndexInfosOfStructuredType(c: Checker, t: Type): IndexInfo[];
+export declare function getIndexInfoOfType(c: Checker, t: Type, keyType: Type): IndexInfo | undefined;
+export declare function getIndexTypeOfType(c: Checker, t: Type, keyType: Type): Type | undefined;
+export declare function getApplicableIndexInfo(c: Checker, t: Type, keyType: Type): IndexInfo | undefined;
+export declare function getApplicableIndexInfoForName(c: Checker, t: Type, name: string): IndexInfo | undefined;
+export declare function findApplicableIndexInfo(c: Checker, indexInfos: readonly IndexInfo[], keyType: Type): IndexInfo | undefined;
+export declare function isApplicableIndexType(c: Checker, source: Type, target: Type): boolean;
+export declare function isArrayLikeType(c: Checker, t: Type): boolean;
+/**
+ * Type parameters' base constraints; primitives' wrapper object types; otherwise the type itself.
+ * Most types are the last case: that test is small enough to inline into callers.
+ */
+export declare function getApparentType(c: Checker, t: Type): Type;
+export declare function isArrayOrTupleOrIntersection(c: Checker, t: Type): boolean;
+export declare function getTypeWithThisArgument(c: Checker, t: Type, thisArgument: Type | undefined, needApparentType: boolean): Type;
+/**
+ * Unions with reducible intersections are reduced; intersections with mutually exclusive
+ * discriminants are `never`.
+ */
+export declare function getReducedType(c: Checker, t: Type): Type;
+export declare function isDiscriminantWithNeverType(c: Checker, prop: Symbol): boolean;
+export declare function isConflictingPrivateProperty(prop: Symbol): boolean;
+export declare function getReducedApparentType(c: Checker, t: Type): Type;
+export declare function getBaseConstraintOfType(c: Checker, t: Type): Type | undefined;
+export declare function getBaseConstraintOrType(c: Checker, t: Type): Type;
+/** `t` with each constituent replaced by its base constraint. */
+export declare function mapToBaseConstraintOrType(c: Checker, t: Type): Type;
+export declare function getResolvedBaseConstraint(c: Checker, t: Type, stack?: RecursionId[]): Type;
+export declare function getConstraintOfType(c: Checker, t: Type): Type | undefined;
+export declare function isReadonlyArray(c: Checker, t: Type): boolean;
+export declare function getTypeFromNodeOrUndefined(c: Checker, node: Node | undefined): Type | undefined;
+export { getReturnTypeOfSignature, getSymbolOfDeclaration, getLateBoundSymbol, instantiateTypes, createSignatureInstantiation, getUnionTypeEx, mapType, };
+export type { Symbol };