@scriptc/compiler 0.1.3 → 0.1.5

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

@@ -9,18 +9,22 @@ import { type ClassInfo } from "./lower-classes.js";
  * `omittable` params (declared `x?: T` or `x: T = e`) may be omitted by a
  * trailing-suffix call, and the frontend appends the interned undefined arm;
  * `rest` (always last) receives the surplus arguments packed into one array
- * literal at each call site. */
-export type ParamMode = "required" | "omittable" | "rest" | "dynRest" | "islandRest";
+ * literal at each call site. `arguments` is a hidden slot containing every
+ * actual argument, including those bound to named parameters. */
+export type ParamMode = "required" | "omittable" | "rest" | "dynRest" | "islandRest" | "arguments";
 /** One parameter of a signature, as call sites and callee prologues see it.
  * `type` is the ABI type — what the emitted C parameter carries: the
  * checker's `T | undefined` union for `x?: T`, a synthesized `T | undefined`
  * union for `x: T = e`, `T[]` for `...xs: T[]`, the plain declared type
- * otherwise. `bodyType` is present exactly for DEFAULTED params: the plain T
- * the body sees after the prologue applies the default (see declareParams). */
+ * otherwise. `bodyType` is present exactly for DEFAULTED program params:
+ * the plain T the body sees after the prologue applies the default (see
+ * declareParams). `callDefault` is the compile-time default value for a
+ * table-backed builtin's omittable slot. */
 export interface ParamShape {
     type: IrType;
     mode: ParamMode;
     bodyType?: IrType;
+    callDefault?: IrExpr;
 }
 export interface FnSig {
     name: string;
@@ -41,6 +45,21 @@ export interface FnSig {
         };
     };
 }
+/** The one func-type projection of completed parameter shapes. Typed rest
+ * parameters keep their packed array as the trailing native ABI slot and
+ * mark the value variadic so indirect call sites run completeArgs before
+ * callValue. Dynamic rest remains the historical hidden ScrDyn slot, while
+ * island rest spells its engine-array slot directly. */
+export declare function funcTypeFromParamShapes(shapes: readonly ParamShape[], ret: IrType): IrType & {
+    kind: "func";
+};
+/** Registers `const alias = overloadedDeclaration` as a compile-time
+ * callable projection. The source function's one implementation ABI is
+ * already collected in fnSigsBySymbol; each direct call still uses the
+ * TS7-resolved overload result bridge. The alias owns no storage, and a
+ * value read materializes the source function's interned closure, so JS
+ * identity (`alias === source`) is preserved. */
+export declare function registerOverloadedCallableAlias(lowerer: Lowerer, decl: ts.VariableDeclaration): boolean;
 export declare function generatorMeta(lowerer: Lowerer, type: IrType & {
     kind: "generator";
 }): NonNullable<IrFunction["generator"]>;
@@ -171,14 +190,6 @@ export declare function paramShapes(lowerer: Lowerer, params: readonly ts.Parame
    * defaultRunner` and `skip: Set<string> = new Set()` arm like any ref
    * kind — the nullable-callback union shape, built by the compiler. */
 export declare function checkDefaultParamBodyType(lowerer: Lowerer, param: ts.ParameterDeclaration, bodyType: IrType): void;
-/** CALL-SITE COMPLETION — the frontend half of the one-signature contract
-   * (docs/ir.md): every call lowers to exactly the callee's full ABI
-   * parameter list, so backends and the validator stay count-exact and no
-   * runtime arity machinery exists. Omitted trailing args for omittable
-   * params become the interned undefined arm (which is also what an
-   * explicitly-passed `undefined` wraps to — both trigger a default, JS-
-   * exact); a rest param packs the surplus args (possibly zero) into one
-   * array literal, evaluated in source order at the call site. */
 export declare function completeArgs(lowerer: Lowerer, argNodes: readonly ts.Expression[], shapes: readonly ParamShape[], loc: SrcLoc, blame: ts.Node, 
 /** Pre-lowered values virtually PREPENDED to the argument list — the
  * tagged-template strings object, which has no ts.Expression to lower
@@ -201,13 +212,12 @@ export declare function wrappedUndefined(lowerer: Lowerer, type: IrType, loc: Sr
    * (direct calls and calls through func-typed values). */
 export declare function omittedArgFor(lowerer: Lowerer, type: IrType, loc: SrcLoc): IrExpr | null;
 export declare function undefinedArgFor(lowerer: Lowerer, type: IrType, loc: SrcLoc, blame: ts.Node): IrExpr;
-/** DECISION (docs/ir.md): function VALUES keep exact-arity semantics — a
-   * func-typed IrType spells one completed signature, so a function whose
-   * declaration has optional/default/rest parameters can become a value only
-   * where the target type spells that exact signature with required
-   * parameters (`x?: T` / `x: T = e` params appear as literal `T | undefined`
-   * unions; a rest signature is never spellable without `...`, which func
-   * types reject). Direct calls get the full feature. */
+/** DECISION (docs/ir.md): function VALUES carry one completed native ABI.
+   * Optional/default parameters appear as literal `T | undefined` slots;
+   * typed rest parameters appear as one trailing typed-array slot plus the
+   * typed-rest marker that makes indirect call sites pack source arguments.
+   * A value is admitted only where its target type projects to that same
+   * completed signature. */
 export declare function requireExactArityValue(lowerer: Lowerer, blame: ts.Node, contextual: ts.Expression | null, shapes: readonly ParamShape[], funcType: IrType): void;
 /** The BODY-facing return type of a (possibly async) function: an async
    * body's `return v` fulfills its promise with v, so the body returns the
@@ -404,10 +414,9 @@ export declare function isTopLevelFnSymbol(lowerer: Lowerer, ident: ts.Identifie
    * holding its own closure would be an RC cycle. */
 export declare function lowerNestedFunctionDecl(lowerer: Lowerer, stmt: ts.FunctionDeclaration): IrStmt;
 /** Signature checks + param shapes + IR func type for any lambda-like
-   * node. The func type's params are the ABI types, so a lambda with
-   * optional/default params has the same IR type as one spelling the
-   * `T | undefined` unions with required params — exactly the exact-arity
-   * value rule (requireExactArityValue decides who may become a value). */
+   * node. The func type's params are the ABI types: optional/default params
+   * become `T | undefined`, and typed rest becomes one packed-array slot.
+   * requireExactArityValue decides whether that completed ABI may escape. */
 export declare function lambdaSignature(lowerer: Lowerer, node: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | ts.MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration): {
     shapes: ParamShape[];
     funcType: IrType & {