tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker-type-factory.d.ts

@@ -0,0 +1,142 @@
+import { type Node } from './ast.js';
+import type { Checker } from './checker.js';
+import { ElementFlags, IndexInfo, IndexType, IndexedAccessType, IntersectionType, LiteralType, ObjectFlags, ObjectType, Signature, StructuredType, SubstitutionType, TupleElementInfo, TupleType, type Type, TypeAlias, TypeFlags, TypeMapper, TypeReference, UnionType } from './checker-types.js';
+import { type Symbol, type SymbolTable } from './symbol.js';
+export declare const enum UnionReduction {
+    None = 0,
+    Literal = 1,
+    Subtype = 2
+}
+export declare const enum IntersectionFlags {
+    None = 0,
+    NoSupertypeReduction = 1,
+    NoConstraintReduction = 2
+}
+export declare function typeListKey(types: readonly Type[]): string;
+export declare function aliasKey(alias: TypeAlias | undefined): string;
+/**
+ * The hash a `TypeListCache` finds `types`, `alias` and `tag` by: two 32-bit hashes of the ids,
+ * combined below 2^53. Takes the alias symbol's id as `aliasKey` would.
+ */
+export declare function typeListHash(types: readonly Type[], alias: TypeAlias | undefined, tag: number): number;
+export declare function newObjectType(c: Checker, objectFlags: ObjectFlags, symbol: Symbol | undefined): ObjectType;
+export declare function newAnonymousType(c: Checker, symbol: Symbol | undefined): ObjectType;
+export declare function createAnonymousType(c: Checker, symbol: Symbol | undefined, members: SymbolTable | undefined, callSignatures: Signature[], constructSignatures: Signature[], indexInfos: IndexInfo[]): ObjectType;
+export declare function setStructuredTypeMembers(c: Checker, t: Type, members: SymbolTable | undefined, callSignatures: Signature[], constructSignatures: Signature[], indexInfos: IndexInfo[]): void;
+export declare function newUnionType(c: Checker, objectFlags: ObjectFlags, types: Type[]): UnionType;
+export declare function newIntersectionType(c: Checker, objectFlags: ObjectFlags, types: Type[]): IntersectionType;
+export declare function newIndexType(c: Checker, target: Type, indexFlags: number): IndexType;
+export declare function newIndexedAccessType(c: Checker, objectType: Type, indexType: Type, accessFlags: number): IndexedAccessType;
+export declare function newSubstitutionType(c: Checker, baseType: Type, constraint: Type): SubstitutionType;
+export declare function newIndexInfo(keyType: Type, valueType: Type, isReadonly: boolean, declaration: Node | undefined): IndexInfo;
+/** Propagates widening, literal and non-inferrable flags from constituents. */
+export declare function getPropagatingFlagsOfTypes(types: readonly Type[], excludeKinds: TypeFlags): ObjectFlags;
+export declare function getStringLiteralType(c: Checker, value: string): LiteralType;
+export declare function getNumberLiteralType(c: Checker, value: number): LiteralType;
+/** `value` is the decimal digits of the bigint, with a leading `-` when negative. */
+export declare function getBigIntLiteralType(c: Checker, value: string): LiteralType;
+export declare function getStringEnumLiteralType(c: Checker, value: string, enumSymbol: Symbol, symbol: Symbol): LiteralType;
+export declare function getNumberEnumLiteralType(c: Checker, value: number, enumSymbol: Symbol, symbol: Symbol): LiteralType;
+export declare function isFreshLiteralType(type: Type): boolean;
+export declare function getFreshTypeOfLiteralType(c: Checker, type: Type): Type;
+export declare function getRegularTypeOfLiteralType(c: Checker, type: Type): Type;
+export declare function isUnitType(type: Type): boolean;
+export declare function isLiteralType(type: Type): boolean;
+export declare function getBaseTypeOfEnumLikeType(c: Checker, type: Type): Type;
+export declare function getBaseTypeOfLiteralType(c: Checker, type: Type): Type;
+export declare function getBaseTypeOfLiteralTypeForComparison(c: Checker, type: Type): Type;
+export declare function getWidenedLiteralType(c: Checker, type: Type): Type;
+export declare function getWidenedUniqueESSymbolType(c: Checker, type: Type): Type;
+export declare function compareNodes(c: Checker, n1: Node | undefined, n2: Node | undefined): number;
+export declare function compareSymbols(c: Checker, s1: Symbol | undefined, s2: Symbol | undefined): number;
+export declare function compareTypeMappers(c: Checker, m1: TypeMapper | undefined, m2: TypeMapper | undefined): number;
+/**
+ * The constituents of a union in the order declaration emit writes them: as in the union, except that
+ * neighbors the union orders by ids, at any depth of `compareTypes`, are ordered by their structure
+ * where that tells them apart. Ids follow the order in which the checker created the types, which
+ * with several checkers depends on the files a checker checked first, so declaration files would
+ * otherwise differ from run to run.
+ */
+export declare function inDeclarationOrder(c: Checker, types: readonly Type[]): readonly Type[];
+/** tsgo's deterministic type order, which orders union constituents. */
+export declare function compareTypes(c: Checker, t1: Type, t2: Type): number;
+/** Binary search position of `t` in the sorted `types`: index if found, else `-(insertion point) - 1`. */
+export declare function binarySearchTypes(c: Checker, types: readonly Type[], t: Type): number;
+export declare function containsType(c: Checker, types: readonly Type[], t: Type): boolean;
+/**
+ * Whether `t` is a constituent of `union`. Equal types are identical, so a large union tested more
+ * than once looks `t` up in a set instead of searching its sorted constituents. Most large unions
+ * are tested once; a few are tested very often.
+ */
+export declare function unionContainsType(c: Checker, union: UnionType, t: Type): boolean;
+/**
+ * Whether `union` contains every type of the sorted `types` (the constituents of another union).
+ * Both lists follow `compareTypes`, so in a small union each type is found by identity after the
+ * previous one; large unions keep `unionContainsType`.
+ */
+export declare function unionContainsSortedTypes(c: Checker, union: UnionType, types: readonly Type[]): boolean;
+/** Inserts `t` into the sorted `types`; returns false if already present. */
+export declare function insertType(c: Checker, types: Type[], t: Type): boolean;
+export declare function someType(type: Type, f: (t: Type) => boolean): boolean;
+export declare function everyType(type: Type, f: (t: Type) => boolean): boolean;
+export declare function everyContainedType(type: Type, f: (t: Type) => boolean): boolean;
+export declare function typesOf(type: Type): Type[];
+export declare function mapType(c: Checker, type: Type, f: (t: Type) => Type | undefined): Type;
+/** Maps union constituents; undefined when every constituent maps to undefined. */
+export declare function mapTypeEx(c: Checker, type: Type, f: (t: Type) => Type | undefined, noReductions: boolean): Type | undefined;
+export declare function mapTypeWithAlias(c: Checker, type: Type, f: (t: Type) => Type, alias: TypeAlias | undefined): Type;
+export declare function filterType(c: Checker, type: Type, f: (t: Type) => boolean): Type;
+export declare function removeType(c: Checker, type: Type, target: Type): Type;
+export declare function countTypes(type: Type): number;
+export declare function isErrorType(c: Checker, type: Type): boolean;
+export declare function getUnionType(c: Checker, types: Type[]): Type;
+export declare function getUnionTypeEx(c: Checker, types: Type[], unionReduction: UnionReduction, alias: TypeAlias | undefined, origin: Type | undefined): Type;
+/** Assumes `types` is sorted and deduplicated. */
+export declare function getUnionTypeFromSortedList(c: Checker, types: Type[], precomputedObjectFlags: ObjectFlags, alias: TypeAlias | undefined, origin: Type | undefined): Type;
+export declare function getTargetType(type: Type): Type;
+/** Whether `t`, whose members are `resolved`, has no members. */
+export declare function isEmptyResolvedType(c: Checker, t: Type, resolved: StructuredType): boolean;
+export declare function isEmptyAnonymousObjectType(c: Checker, t: Type): boolean;
+export declare function isEmptyObjectType(c: Checker, t: Type): boolean;
+export declare function isPatternLiteralPlaceholderType(c: Checker, t: Type): boolean;
+export declare function isPatternLiteralType(c: Checker, t: Type): boolean;
+export declare function isGenericStringLikeType(c: Checker, t: Type): boolean;
+export declare function intersectTypes(c: Checker, type1: Type | undefined, type2: Type | undefined): Type | undefined;
+export declare function getIntersectionType(c: Checker, types: Type[]): Type;
+export declare function getIntersectionTypeEx(c: Checker, types: Type[], flags: IntersectionFlags, alias: TypeAlias | undefined): Type;
+export declare function isPrimitiveOrObjectOrEmptyType(c: Checker, t: Type): boolean;
+export declare function containsMissingType(c: Checker, t: Type): boolean;
+export declare function getCrossProductUnionSize(types: readonly Type[]): number;
+export declare function checkCrossProductUnion(c: Checker, types: readonly Type[]): boolean;
+export declare function getUnionOrIntersectionType(c: Checker, types: Type[], isUnion: boolean, reduction: UnionReduction): Type;
+export declare function createTypeReference(c: Checker, target: Type, typeArguments: Type[]): Type;
+export declare function createTypeReferenceEx(c: Checker, target: Type, typeArguments: Type[], objectFlags: ObjectFlags): Type;
+export declare function tryCreateTypeReference(c: Checker, target: Type, typeArguments: Type[]): Type;
+export declare function createDeferredTypeReference(c: Checker, target: Type, node: Node, mapper: TypeMapper | undefined, alias: TypeAlias | undefined): TypeReference;
+export declare function cloneTypeReference(c: Checker, source: TypeReference): TypeReference;
+export declare function createTypeFromGenericGlobalType(c: Checker, genericGlobalType: Type, typeArguments: Type[]): Type;
+export declare function createArrayType(c: Checker, elementType: Type): Type;
+export declare function createArrayTypeEx(c: Checker, elementType: Type, readonly: boolean): Type;
+export declare function isTupleType(t: Type): boolean;
+export declare function tupleTargetOf(t: Type): TupleType;
+export declare function isGenericTupleType(t: Type): boolean;
+export declare function isArrayType(c: Checker, t: Type): boolean;
+export declare function isReadonlyArrayType(c: Checker, t: Type): boolean;
+export declare function isArrayOrTupleType(c: Checker, t: Type): boolean;
+export declare function isMutableArrayOrTuple(c: Checker, t: Type): boolean;
+export declare function getTypeReferenceArity(t: Type): number;
+export declare function getElementTypes(c: Checker, t: Type): Type[];
+export declare function getStartElementCount(t: TupleType, flags: ElementFlags): number;
+export declare function getEndElementCount(t: TupleType, flags: ElementFlags): number;
+export declare function getTotalFixedElementCount(t: TupleType): number;
+export declare function createTupleType(c: Checker, elementTypes: Type[]): Type;
+export declare function createTupleTypeEx(c: Checker, elementTypes: Type[], elementInfos: TupleElementInfo[], readonly: boolean): Type;
+export declare function getTupleTargetType(c: Checker, elementInfos: TupleElementInfo[], readonly: boolean): Type;
+export declare function createNormalizedTypeReference(c: Checker, target: Type, typeArguments: Type[]): Type;
+export declare function createNormalizedTupleType(c: Checker, target: TupleType, elementTypes: Type[], objectFlags: ObjectFlags): Type;
+/** Type arguments of a reference, resolving deferred ones from their type node. */
+export declare function getTypeArguments(c: Checker, t: Type): Type[];
+export declare function getTemplateLiteralType(c: Checker, texts: string[], types: Type[]): Type;
+export declare function getTemplateStringForType(c: Checker, t: Type): string;
+/** JavaScript's Number::toString. */
+export declare function numberToString(value: number): string;