@scriptc/compiler 0.0.8 → 0.0.10

package/dist/frontend/lowering/lower-calls.d.ts

@@ -373,6 +373,36 @@ export declare const TIMER_MODULE_MEMBERS: ReadonlySet<string>;
    * timer function (the caller's fence machinery takes over). */
 export declare function lowerTimersMemberCall(L: Lowerer, expr: ts.CallExpression, member: string, loc: SrcLoc): IrExpr | null;
 export declare function lowerCall(L: Lowerer, expr: ts.CallExpression): IrExpr;
+/** The RUNTIME-ARITY spread call — `f(...args)`, the rest-forwarding idiom
+   * (`const f = (...args) => from(...args)`): a spread whose length is a
+   * runtime fact has no home in the compile-time completion, so the call
+   * rides a dynamic boundary instead. Two lanes, picked by the spread
+   * source's tier:
+   *
+   * - CHECKED-DYNAMIC (dyn spread sources — a JS rest binding, a dyn
+   *   value): box the callee (dynFrom; a dyn callee is already boxed),
+   *   convert every argument into dyn, and emit the spread-marked dynCall
+   *   — the emitters build one fresh DOM argument array (spreads flatten
+   *   left-to-right, non-iterables throw V8's TypeError) and apply through
+   *   it; the boxed thunk delivers JS arity exactly. Result dyn, checked
+   *   per use like every any-origin value.
+   * - ISLAND (a jsval spread source — the --dynamic rest binding is the
+   *   engine's own arguments array): marshal the callee in and emit jsOp
+   *   callSpread — the prelude helper's REAL `f(...pre, ...s)`, so
+   *   iterator protocols and the not-iterable TypeError are the engine's
+   *   own. One trailing spread after the fixed arguments is the modeled
+   *   shape (exactly the forwarding idiom).
+   *
+   * Answers null when neither lane fits (typed .ts spreads keep
+   * completeArgs' rest packing and its fences). JS sources only — the
+   * same guard as the over-arity dynCall precedent. */
+export declare function lowerSpreadArgsCall(L: Lowerer, expr: ts.CallExpression, callee: IrExpr, loc: SrcLoc): IrExpr | null;
+/** True when a spread argument lands where the compile-time completion
+   * cannot take it — a FIXED parameter position, or a dynamic rest slot
+   * (dynRest/islandRest, whose packs are built per-argument): the shapes
+   * the runtime-arity lane (lowerSpreadArgsCall) serves. Typed `rest`
+   * slots keep completeArgs' same-element spread packing. */
+export declare function spreadNeedsRuntimeArity(shapes: readonly ParamShape[], argNodes: readonly ts.Expression[]): boolean;
 /** The SHARED prototype names scr_dyn_invoke dispatches at runtime (the
  * subset of DOM_PROTO_METHOD_NAMES with a receiver-kind dispatch): the
  * runtime runs the real method for the receiver's kind, throws Node's
@@ -547,6 +577,47 @@ export declare function objLitGenericFnInfoOf(L: Lowerer, blame: ts.Node, name:
    * bindings are read-only — no other file can write one. Cached per
    * symbol (the scan walks the whole file once). */
 export declare function bindingNeverReassigned(L: Lowerer, sym: ts.Symbol, decl: ts.Node): boolean;
+/** Strips the value-preserving wrappers off an expression: parens,
+   * non-null assertions, `as`/`satisfies`/angle-bracket casts. What
+   * remains is the expression that actually evaluates. */
+export declare function stripValueWrappers(e: ts.Expression): ts.Expression;
+/** The nullish unit `e` provably evaluates to: a bare null/undefined
+   * literal (assertion-wrapped — `null as any`, `null!`), or a read of a
+   * registered NULLISH binding (nullishGenericBindingUnitOf). Null when
+   * the value could be anything else. */
+export declare function nullishExprUnitOf(L: Lowerer, e: ts.Expression): "null" | "undefined" | null;
+/** The nullish unit a binding provably holds FOREVER, by VALUE alone: its
+   * initializer is nullish (`const i: I<A & B> = null as any`) and every
+   * write in its declaring file is nullish too (`a = b` where b is
+   * another nullish binding). No type condition — callers add their own
+   * (nullishGenericBindingUnitOf gates the no-storage family on
+   * unmappable types; the generic-method call path rescues its fence with
+   * the value fact alone). Cached per symbol; the pre-seeded null entry
+   * guards probe cycles (mutually-assigned bindings resolve link by link,
+   * declaration order). */
+export declare function nullishValueUnitOf(L: Lowerer, sym: ts.Symbol | null): "null" | "undefined" | null;
+/** nullishValueUnitOf gated on a declared type that CANNOT hold the
+   * value — the NO-STORAGE family: an unmappable type has no other story,
+   * and a RECORD-mapped one (`const i: I<A & B> = null as any` — an
+   * interface whose members are all generic signatures interns an empty
+   * shape) has a slot null can never inhabit, so storing would throw the
+   * representation error where Node stores null silently. Either way the
+   * declaration emits nothing and reads know the value. Null-tolerant
+   * mappings (unions with a null/undefined arm, dyn) keep their real
+   * storage and every ordinary lowering. */
+export declare function nullishGenericBindingUnitOf(L: Lowerer, sym: ts.Symbol | null): "null" | "undefined" | null;
+/** True when `sym` — a binding whose type has NO static mapping — is DEAD:
+   * never read anywhere in the program, not exported through a specifier,
+   * declared with no initializer or a side-effect-free one, and written
+   * (if at all) only by plain assignments of side-effect-free values. Node
+   * materializes those values and drops them — zero observable effect —
+   * so the declaration and its writes lower to NOTHING instead of fencing
+   * on a type the program never consumes (`var xs2: typeof Array;`, the
+   * write-only `var f2: { <T, U>(x: T, y: U): T }`). TS program files
+   * only: JS bindings keep their checked-dynamic fallbacks. Positive
+   * answers register in L.deadBindings (the assignment lowering skips
+   * writes by the same set). */
+export declare function deadUnmappableBinding(L: Lowerer, sym: ts.Symbol | null, decl: ts.VariableDeclaration): boolean;
 /** The generic function-like INITIALIZER behind a binding declaration —
    * `const f = <T>(x: T) => x` or `const f = function g<T>(x: T) {...}`
    * (parens stripped). Null when the declaration isn't that shape; the
@@ -600,17 +671,6 @@ export declare function bindingGenericFnAliasInfoOf(L: Lowerer, decl: ts.Variabl
    * structurally identical literal with a DIFFERENT body, which static
    * resolution would silently miss. */
 export declare function requireObjLitGenericReceiver(L: Lowerer, blame: ts.Node, recvExpr: ts.Expression, literal: ts.ObjectLiteralExpression, name: string): void;
-/** `o.m(args)` where `m` is an object-literal GENERIC method (own type
-   * parameters — the member is excluded from the record shape, see
-   * isGenericCallableMemberType): monomorphized per call site against the
-   * DEFINING literal's declaration, exactly like top-level generic
-   * functions. Resolution is static, so the receiver must provably BE the
-   * defining literal: a const binding whose initializer is that literal,
-   * read directly. The receiver read is pure and the compiled instance is
-   * a plain module function (no `this`, fenced), so the call lowers to a
-   * direct `call` of the instance with the receiver unevaluated. Claims
-   * every call whose member is generic-callable — lowering it or fencing
-   * with a named message. */
 export declare function lowerObjLitGenericMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `obj.method(args)` — whole-program devirtualization decides the form:
    * a method some strict subclass of the receiver's STATIC class overrides