tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,179 @@
+import { type Node } from './ast.js';
+import { type Symbol } from './symbol.js';
+import type { Checker } from './checker.js';
+import { type ConditionalRoot, type IndexType, type MappedType, type ReverseMappedType, type Signature, type TemplateLiteralType, type Type, TypeMapper } from './checker-types.js';
+import { type TypeComparer } from './relations.js';
+export declare const enum InferenceFlags {
+    None = 0,
+    /** Infer `silentNeverType` for no inferences (otherwise `unknown`). */
+    NoDefault = 1,
+    /** Infer `any` for no inferences. */
+    AnyDefault = 2,
+    /** A generic function was skipped during inference. */
+    SkippedGenericFunction = 4
+}
+export declare const enum InferencePriority {
+    None = 0,
+    /** Naked type variable in union or intersection type. */
+    NakedTypeVariable = 1,
+    SpeculativeTuple = 2,
+    /** Source originated within a substitution type's substitute. */
+    SubstituteSource = 4,
+    HomomorphicMappedType = 8,
+    PartialHomomorphicMappedType = 16,
+    MappedTypeConstraint = 32,
+    ContravariantConditional = 64,
+    /** Inference made from the return type of a generic function. */
+    ReturnType = 128,
+    LiteralKeyof = 256,
+    /** Don't infer from constraints of instantiable types. */
+    NoConstraints = 512,
+    /** Always use strict rules for contravariant inferences. */
+    AlwaysStrict = 1024,
+    MaxValue = 2048,
+    /** Inference circularity, less than all other priorities. */
+    Circularity = -1,
+    PriorityImpliesCombination = 416
+}
+/** Inferences for one type parameter. */
+export declare class InferenceInfo {
+    readonly typeParameter: Type;
+    /** Covariant candidates, in decreasing depth order. */
+    candidates: Type[];
+    candidateDepths: number[];
+    contraCandidates: Type[];
+    inferredType: Type | undefined;
+    priority: InferencePriority;
+    /** Whether all inferences are to top-level occurrences. */
+    topLevel: boolean;
+    isFixed: boolean;
+    impliedArity: number;
+    constructor(typeParameter: Type);
+    clone(): InferenceInfo;
+}
+export declare class IntraExpressionInferenceSite {
+    readonly node: Node;
+    readonly type: Type;
+    constructor(node: Node, type: Type);
+}
+export declare class InferenceContext {
+    inferences: InferenceInfo[];
+    /** The generic signature inferences are made for, if any. */
+    readonly signature: Signature | undefined;
+    flags: InferenceFlags;
+    readonly compareTypes: TypeComparer;
+    /** Fixes inferences. */
+    mapper: TypeMapper;
+    nonFixingMapper: TypeMapper;
+    /** Maps to inferences from the return type, if any. */
+    returnMapper: TypeMapper | undefined;
+    outerReturnMapper: TypeMapper | undefined;
+    inferredTypeParameters: Type[] | undefined;
+    intraExpressionInferenceSites: IntraExpressionInferenceSite[];
+    constructor(c: Checker, inferences: InferenceInfo[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer);
+}
+/** Maps a context's type parameters to their inferred types, optionally fixing them. */
+export declare class InferenceTypeMapper extends TypeMapper {
+    readonly c: Checker;
+    readonly context: InferenceContext;
+    readonly fixing: boolean;
+    constructor(c: Checker, context: InferenceContext, fixing: boolean);
+    map(type: Type): Type;
+}
+export declare function createInferenceContext(c: Checker, typeParameters: readonly Type[], signature: Signature | undefined, flags: InferenceFlags, compareTypes: TypeComparer | undefined): InferenceContext;
+export declare function cloneInferenceContext(c: Checker, context: InferenceContext, extraFlags: InferenceFlags): InferenceContext;
+export declare function cloneInferredPartOfContext(c: Checker, context: InferenceContext): InferenceContext | undefined;
+export declare function getMapperFromContext(context: InferenceContext | undefined): TypeMapper | undefined;
+/** The context's return mapper combined with a mapper erasing its other type parameters to their current inferences. */
+export declare function createOuterReturnMapper(c: Checker, context: InferenceContext): TypeMapper;
+export declare function addIntraExpressionInferenceSite(context: InferenceContext, node: Node, type: Type): void;
+export declare function clearCachedInferences(inferences: InferenceInfo[]): void;
+export declare function hasInferenceCandidates(info: InferenceInfo): boolean;
+export declare function hasInferenceCandidatesOrDefault(info: InferenceInfo): boolean;
+export declare function someInferenceHasCandidates(inferences: InferenceInfo[]): boolean;
+export declare function everyInferenceHasCandidates(inferences: InferenceInfo[]): boolean;
+export declare function someInferenceHasCandidatesOrDefault(inferences: InferenceInfo[]): boolean;
+export declare function hasOverlappingInferences(a: InferenceInfo[], b: InferenceInfo[]): boolean;
+export declare function mergeInferences(target: InferenceInfo[], source: InferenceInfo[]): void;
+/** Infers from `source` to `target` for the type parameters of `inferences`. */
+export declare function inferTypes(c: Checker, inferences: InferenceInfo[], source: Type, target: Type, priority: InferencePriority, contravariant: boolean): void;
+export declare function isTypeParameterAtTopLevel(c: Checker, t: Type, tp: Type, depth: number): boolean;
+export declare function isConstTypeVariable(c: Checker, t: Type | undefined, depth: number): boolean;
+export declare function isMutableArrayLikeType(c: Checker, t: Type): boolean;
+/** Calls `callback` with each pair of corresponding parameter types of `source` and `target`. */
+export declare function applyToParameterTypes(c: Checker, source: Signature, target: Signature, callback: (s: Type, t: Type) => void): void;
+export declare function applyToReturnTypes(c: Checker, source: Signature, target: Signature, callback: (s: Type, t: Type) => void): void;
+/** `signature` with its type parameters replaced by their base constraints. */
+export declare function getBaseSignature(c: Checker, signature: Signature): Signature;
+export declare function getTypeParametersForMapper(c: Checker, signature: Signature): Type[];
+/** The generic `signature` instantiated in the context of the non-generic `contextualSignature`. */
+export declare function instantiateSignatureInContextOf(c: Checker, signature: Signature, contextualSignature: Signature, inferenceContext: InferenceContext | undefined, compareTypes: TypeComparer | undefined): Signature;
+/**
+ * Whether `source`, a string literal or a template literal type, fails the start and end text test of
+ * `inferFromLiteralPartsToTemplateLiteral` against `target`: its first text does not start with the
+ * target's first text, its last text does not end with the target's last text, or a string literal
+ * is shorter than both. `inferTypesFromTemplateLiteralType` returns undefined then.
+ */
+export declare function failsTemplateLiteralTextTest(source: Type, target: TemplateLiteralType): boolean;
+/**
+ * Whether `source` is a string literal, or a template literal type whose placeholders are `string`,
+ * `number` or `bigint`, that fails the start and end text test against `target`. It is then not
+ * assignable to `target`, and relating the two has no other effect: such a template has no type
+ * variables for a variance marker mapper to find.
+ */
+export declare function isUnmatchedTemplateLiteralKey(source: Type, target: TemplateLiteralType): boolean;
+/** The types matched by `target`'s placeholders in `source`, or undefined if it doesn't match. */
+export declare function inferTypesFromTemplateLiteralType(c: Checker, source: Type, target: TemplateLiteralType): Type[] | undefined;
+export declare function isValidNumberString(s: string, roundTripOnly: boolean): boolean;
+/** Whether `s` scans as a bigint literal without separators; round-trippable ones print as written. */
+export declare function isValidBigIntString(s: string, roundTripOnly: boolean): boolean;
+/** Infers a source type for the homomorphic mapped type `{ [P in keyof T]: X }`, cached. */
+export declare function inferTypeForHomomorphicMappedType(c: Checker, source: Type, target: MappedType, constraint: IndexType): Type | undefined;
+export declare function inferReverseMappedType(c: Checker, source: Type, target: MappedType, constraint: IndexType): Type | undefined;
+export declare function resolveReverseMappedTypeMembers(c: Checker, t: ReverseMappedType): void;
+export declare function getTypeOfReverseMappedSymbol(c: Checker, symbol: Symbol): Type;
+export declare function instantiateReverseMappedType(c: Checker, t: ReverseMappedType, mapper: TypeMapper): Type;
+/** Infers early from intra-expression sites (context-sensitive elements of object and array literals). */
+export declare function inferFromIntraExpressionSites(c: Checker, context: InferenceContext): void;
+export declare function getInferredType(c: Checker, context: InferenceContext, index: number): Type;
+export declare function getInferredTypes(c: Checker, context: InferenceContext): Type[];
+export declare function getTypeFromInference(c: Checker, inference: InferenceInfo): Type | undefined;
+export declare function getCommonSupertype(c: Checker, types: Type[]): Type;
+/** The leftmost type no type to its right is a subtype of. */
+export declare function getCommonSubtype(c: Checker, types: Type[]): Type;
+/** A mapper from a conditional type's `infer` type parameters to their inferences. */
+export declare function inferTypesForConditional(c: Checker, root: ConditionalRoot, checkType: Type, extendsType: Type, mapper: TypeMapper | undefined, checkTypeDeferred: boolean): TypeMapper | undefined;
+/** Caches and stacks for inference, contextual typing and call resolution. */
+export declare class InferenceCaches {
+    /**
+     * Contextual types pushed for nodes being checked, innermost last. The first `contextualDepth`
+     * entries are live; popping keeps the slots after them for reuse.
+     */
+    readonly contextualNodes: Node[];
+    readonly contextualTypes: (Type | undefined)[];
+    readonly contextualIsCache: boolean[];
+    contextualDepth: number;
+    /** Inference contexts pushed for arguments being checked, innermost last; `inferenceDepth` are live. */
+    readonly inferenceNodes: Node[];
+    readonly inferenceContexts: (InferenceContext | undefined)[];
+    inferenceDepth: number;
+    readonly optionalCallSignatures: Map<Signature, Map<string, Signature>>;
+    readonly discriminatedContextualTypes: Map<string, Type>;
+    /** `discriminatedContextualTypes` by node and type id packed into one number, when they fit. */
+    readonly discriminatedContextualTypesById: Map<number, Type>;
+    /** For union contextual types, what each constituent has for a missing optional property (discriminateTypeByObjectLiteral). */
+    readonly missingPropertyStates: Map<Type, Map<string, number>>;
+    readonly contextFreeTypes: Map<Node, Type>;
+    readonly reverseMapped: Map<string, Type | undefined>;
+    readonly reverseHomomorphicMapped: Map<string, Type | undefined>;
+    /** inferReverseMappedType's recursion stacks; the first `reverseStackDepth` entries of each are live. */
+    readonly reverseSourceStack: Type[];
+    readonly reverseTargetStack: Type[];
+    reverseStackDepth: number;
+    reverseExpandingFlags: number;
+}
+/**
+ * The constraint an `infer T` position implies, e.g. `unknown[]` in a rest position; with
+ * `omitTypeReferences`, `Foo<infer T>` implies none.
+ */
+export declare function getInferredTypeParameterConstraint(c: Checker, t: Type, omitTypeReferences?: boolean): Type | undefined;