tsc-ts 0.0.10 → 0.1.1

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

@@ -1,7 +1,8 @@
 import { type Node } from './ast.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';
+import { type TemplateTypeComparer } from './checker-type-operators.js';
+import { type TypeComparer, type RecursionId } from './relations.js';
 import { type Symbol } from './symbol.js';
 export declare const enum InferenceFlags {
     None = 0,
@@ -10,7 +11,9 @@ export declare const enum InferenceFlags {
     /** Infer `any` for no inferences. */
     AnyDefault = 2,
     /** A generic function was skipped during inference. */
-    SkippedGenericFunction = 4
+    SkippedGenericFunction = 4,
+    /** Inferences other than pure return type inferences are not filtered by their constraints. */
+    NoConstraintChecks = 8
 }
 export declare const enum InferencePriority {
     None = 0,
@@ -38,9 +41,8 @@ export declare const enum InferencePriority {
 /** Inferences for one type parameter. */
 export declare class InferenceInfo {
     readonly typeParameter: Type;
-    /** Covariant candidates, in decreasing depth order. */
+    /** Covariant candidates. */
     candidates: Type[];
-    candidateDepths: number[];
     contraCandidates: Type[];
     inferredType: Type | undefined;
     priority: InferencePriority;
@@ -107,6 +109,50 @@ export declare function hasOverlappingInferences(a: InferenceInfo[], b: Inferenc
 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;
+declare const enum UnstartedInferenceState {
+    /** Walked once, which may have resolved the types the walk reaches. Nothing is kept. */
+    Seen = 0,
+    /** Walked twice; the second walk created no types and left `inferences`. */
+    Walked = 1,
+    /** A third walk did the same as the second, so later walks are skipped. */
+    Confirmed = 2,
+    /** Always walked: walks differed or created types, or one reported a diagnostic or met a circularity. */
+    Unusable = 3
+}
+/** A memoized `inferTypesFromUnstarted` walk. */
+export declare class UnstartedInference {
+    readonly state: UnstartedInferenceState;
+    readonly inferences: InferenceInfo[];
+    /** The instantiations the walk does, which a skipped walk adds to the counts. */
+    readonly instantiations: number;
+    /** The instantiation depth the confirming walk started at: a walk starting deeper might reach the limit. */
+    readonly depth: number;
+    /** The variance reliability flags the walk reports. */
+    readonly reliabilityFlags: number;
+    /** The unions and intersections the walk searched before their properties were resolved. */
+    readonly searched: readonly Type[];
+    constructor(state: UnstartedInferenceState, inferences: InferenceInfo[], instantiations: number, depth: number, reliabilityFlags: number, searched: readonly Type[]);
+}
+/**
+ * `inferTypes` into the inferences for `signature`'s type parameters, to `target`, which is
+ * determined by `signature` (its return type). When no inference has started, the walk depends only
+ * on `signature`, `source` and `priority`, so it is memoized per checker. Contextual return type
+ * inference repeats the same walk for calls of a generic function with the same contextual type at
+ * different call sites.
+ *
+ * A walk is skipped only when it would add nothing but the inferences:
+ * - Once a second and a third walk have both created no types or signatures and done the same. The
+ *   first walk resolves the types it reaches; only walks that repeat keep their inferences.
+ * - With the instantiation count and depth replayed. The walk is skipped only where it could not
+ *   reach the instantiation limits.
+ * - With the variance reliability flags replayed.
+ * - Never when a walk reported a diagnostic or met a circularity. Never during a variance
+ *   computation, where relations are not cached and circularities are found differently.
+ * - Only while the unions and intersections whose unresolved properties the walk searched
+ *   (hasUnmatchedProperty) are still unresolved. Once they are resolved, the same walk creates the
+ *   property types, so it is learned again.
+ */
+export declare function inferTypesFromUnstarted(c: Checker, signature: Signature, inferences: InferenceInfo[], source: Type, target: Type, priority: InferencePriority): 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;
@@ -133,7 +179,11 @@ export declare function failsTemplateLiteralTextTest(source: Type, target: Templ
  */
 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;
+/**
+ * The types that `source` gives the placeholders of `target`. A placeholder of a source template with the same
+ * texts keeps its type where `compareTypes` (assignability by default) relates their base constraints.
+ */
+export declare function inferTypesFromTemplateLiteralType(c: Checker, source: Type, target: TemplateLiteralType, compareTypes?: TemplateTypeComparer): 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;
@@ -176,14 +226,36 @@ export declare class InferenceCaches {
     readonly contextFreeTypes: Map<Node, Type>;
     readonly reverseMapped: Map<string, Type | undefined>;
     readonly reverseHomomorphicMapped: Map<string, Type | undefined>;
+    /**
+     * invokeOnce's recursion stacks, shared by the checker's inference walks, with the mode of each visit and the
+     * recursion identities isDeeplyNestedStackEntry keeps for each entry. The first `invokeStackDepth` entries are live.
+     * A walk's entries start where the live entries end when it starts (`InferenceState.stackBase`), so a walk started
+     * during another one keeps the other's entries.
+     */
+    readonly invokeSourceStack: Type[];
+    readonly invokeTargetStack: Type[];
+    readonly invokeModeStack: number[];
+    readonly invokeSourceIdentities: RecursionId[];
+    readonly invokeTargetIdentities: RecursionId[];
+    invokeStackDepth: number;
     /** inferReverseMappedType's recursion stacks; the first `reverseStackDepth` entries of each are live. */
     readonly reverseSourceStack: Type[];
     readonly reverseTargetStack: Type[];
     reverseStackDepth: number;
     reverseExpandingFlags: number;
+    /**
+     * What `inferTypesFromUnstarted` left in each inference, by signature id, then by source type id
+     * times 4096 plus the priority.
+     */
+    readonly unstartedInferences: Map<number, Map<number, UnstartedInference>>;
+    /** The `unstartedInferences` entry of a walk seen once. */
+    readonly seenOnce: UnstartedInference;
+    /** The `unstartedInferences` entry of a walk that is never skipped. */
+    readonly alwaysWalked: UnstartedInference;
 }
 /**
  * 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;
+export {};