tsc-ts 0.0.4 → 0.0.5

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

@@ -0,0 +1,120 @@
+import { type Node, NodeVisitor } from './ast.js';
+import { type FlowNode } from './flow.js';
+import type { Checker } from './checker.js';
+import { type Type, type UnionType, Signature } from './checker-types.js';
+import { type Symbol } from './symbol.js';
+/** The state of one `getFlowTypeOfReference` walk. `incomplete` describes the last returned type. */
+export declare class FlowState {
+    reference: Node;
+    declaredType: Type;
+    initialType: Type;
+    flowContainer: Node | undefined;
+    refKey: string | undefined;
+    depth: number;
+    sharedFlowStart: number;
+    incomplete: boolean;
+    /** The flow nodes visited, and the deepest nesting of the walk. */
+    steps: number;
+    maxDepth: number;
+    /** Whether this walk may be kept and end on a kept one (`FlowWalk`), and whether it looked one up. */
+    keepsWalk: boolean;
+    lookedUp: boolean;
+    /** The reference's last long walk, which this walk may end on. */
+    walk: FlowWalk | undefined;
+    /** The node where this walk would be kept from: see `flowWalkAnchorSteps`. */
+    anchor: FlowNode | undefined;
+    /** Whether the result depends on where the reference is, not only on its key. */
+    positional: boolean;
+    constructor(reference: Node, declaredType: Type, initialType: Type, flowContainer: Node | undefined);
+    /** Prepares a free flow state for another walk. */
+    reset(reference: Node, declaredType: Type, initialType: Type, flowContainer: Node | undefined): void;
+}
+/**
+ * A node of a reference's last long walk, and the walk's result. Without loops or reduce labels in
+ * effect, the type of a reference at a flow node doesn't change, so a later walk that reaches `start`
+ * ends there. In a long list of top-level declarations, each reference otherwise walks back over
+ * every one before it.
+ */
+export declare class FlowWalk {
+    start: FlowNode;
+    type: Type;
+    /** The deepest nesting of a walk from `start`, which reaches the depth limit the same way. */
+    depth: number;
+    constructor(start: FlowNode, type: Type, depth: number);
+}
+/** A loop junction being analyzed for a reference, with the types seen on its paths so far. */
+export declare class FlowLoopInfo {
+    readonly flow: FlowNode;
+    readonly refKey: string;
+    readonly types: Type[];
+    constructor(flow: FlowNode, refKey: string, types: Type[]);
+}
+/** The type of `reference` at its flow position, narrowed from `declaredType` starting at `initialType`. */
+export declare function getFlowTypeOfReference(c: Checker, reference: Node, declaredType: Type, initialType: Type, flowContainer: Node | undefined): Type;
+/** `getFlowTypeOfReference` at `flowNode`, for pseudo-references such as binding patterns. */
+export declare function getFlowTypeOfReferenceAt(c: Checker, reference: Node, declaredType: Type, initialType: Type, flowContainer: Node | undefined, flowNode: FlowNode | undefined): Type;
+export declare function getTypeAtFlowNode(c: Checker, f: FlowState, start: FlowNode): Type;
+export declare function convertAutoToAny(c: Checker, t: Type): Type;
+/** A branch label's antecedents, as limited by the innermost reduce label being passed that targets it. */
+export declare function getBranchLabelAntecedents(c: Checker, flow: FlowNode): FlowNode[];
+/** The type of an initializer: the type a variable was inferred from, else computed without caching. */
+export declare function getTypeOfInitializer(c: Checker, node: Node): Type;
+/** The constituents of `declaredType` that some constituent of `assignedType` is assignable to. */
+export declare function getAssignmentReducedType(c: Checker, declaredType: Type, assignedType: Type): Type;
+/** The signature of a call whose effects (type predicates, `never` returns) apply to control flow. */
+export declare function getEffectsSignature(c: Checker, node: Node): Signature | undefined;
+export declare function recombineUnknownType(c: Checker, t: Type): Type;
+/** `t` narrowed to `candidate` (or with it removed when `assumeTrue` is false). */
+export declare function getNarrowedType(c: Checker, t: Type, candidate: Type, assumeTrue: boolean, checkDerived: boolean): Type;
+/** The name of a property usable to index the constituents of a large union by literal values, or ''. */
+export declare function getKeyPropertyName(c: Checker, t: UnionType): string;
+export declare function getConstituentTypeForKeyType(c: Checker, t: UnionType, keyType: Type): Type | undefined;
+/** Whether every value of the switch expression is handled by a case. */
+export declare function isExhaustiveSwitchStatement(c: Checker, statement: Node): boolean;
+export declare function isMatchingReference(c: Checker, source: Node, target: Node): boolean;
+export declare function getAccessedPropertyName(c: Checker, access: Node): string | undefined;
+/** The property name a constant or enum member used as an index stands for. */
+export declare function tryGetNameFromEntityNameExpression(c: Checker, node: Node): string | undefined;
+export declare function tryGetNameFromType(t: Type): string | undefined;
+/** The property name or element index a destructuring element reads. */
+export declare function getDestructuringPropertyName(c: Checker, node: Node): string | undefined;
+export declare function isConstantReference(c: Checker, node: Node): boolean;
+export declare function hasMatchingArgument(c: Checker, call: Node, reference: Node): boolean;
+export declare function isReachableFlowNode(c: Checker, flow: FlowNode): boolean;
+export declare const enum AssignmentKind {
+    None = 0,
+    Definite = 1,
+    Compound = 2
+}
+export declare function getAssignmentTargetKind(node: Node): AssignmentKind;
+export declare function isInCompoundLikeAssignment(node: Node): boolean;
+export declare function isConstantVariable(_c: Checker, symbol: Symbol): boolean;
+export declare function isParameterOrMutableLocalVariable(_c: Checker, symbol: Symbol): boolean;
+export declare function isMutableLocalVariableDeclaration(declaration: Node): boolean;
+export declare function isSymbolAssigned(c: Checker, symbol: Symbol): boolean;
+export declare function isSymbolAssignedDefinitely(c: Checker, symbol: Symbol): boolean;
+/** Whether there are no assignments to `symbol`, or `location` is past the last one. */
+export declare function isPastLastAssignment(c: Checker, symbol: Symbol, location: Node | undefined): boolean;
+/** Records the last assignment position of parameters and mutable locals in one walk. */
+export declare class AssignmentMarker extends NodeVisitor {
+    readonly c: Checker;
+    constructor(c: Checker);
+    visitNode(node: Node): boolean;
+}
+/** The function, module block, source file or property declaration whose flow graph contains `node`. */
+export declare function getControlFlowContainer(node: Node): Node;
+/** The evolving array type of `let x = []` with the element types added so far. */
+export declare function getEvolvingArrayType(c: Checker, elementType: Type): Type;
+/**
+ * Whether `node` is `x` in `x.length`, `x.push(v)`, `x.unshift(v)` or `x[n] = v` with a numeric,
+ * undefined or any `n`.
+ */
+export declare function isEvolvingArrayOperationTarget(c: Checker, node: Node): boolean;
+/** The array type an evolving array settles on; `any[]` while it has no elements. */
+export declare function finalizeEvolvingArrayType(c: Checker, t: Type): Type;
+/**
+ * The type of `symbol` at `location`. A destructured variable of a const declaration or unassigned
+ * parameter is narrowed by checks of its siblings: in `const { kind, payload } = action`, testing
+ * `kind` narrows `payload`.
+ */
+export declare function getNarrowedTypeOfSymbol(c: Checker, symbol: Symbol, location: Node): Type;