@scriptc/compiler 0.1.6 → 0.2.0

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

@@ -1,8 +1,10 @@
 import * as ts from "../ts7/adapter.js";
+import { bodyReadsArguments } from "../arguments-usage.js";
 import type { Lowerer } from "./lowerer.js";
-import { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
+import { type IrExpr, type IrFunction, type IrStmt, type IrType, type SrcLoc } from "../../ir/ir.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type ClassInfo } from "./lower-classes.js";
+export { bodyReadsArguments };
 /** How a parameter participates in CALL-SITE COMPLETION (the frontend
  * completes every call to the one full signature, so the IR and backends
  * stay count-exact — see docs/ir.md). `required` params must be passed;
@@ -13,7 +15,7 @@ import { type ClassInfo } from "./lower-classes.js";
  * 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
+ * `type` is the ABI type — what the emitted LLVM 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 program params:
@@ -99,12 +101,15 @@ export interface GenericFnInfo {
      * Instance methods take `this` (object:<declarer>) as param 0 and lower
      * under the declarer's instantiation bindings (generic-class receivers)
      * MERGED with the method instantiation's own; statics lower as plain
-     * module functions with the static-method this/super fence. Absent for
+     * module functions with an exact receiver or the this/super fence. Absent for
      * top-level functions and object-literal methods. */
     member?: {
         cls: ClassInfo;
         kind: "method" | "static";
     };
+    /** Direct static calls specialize lexical this for the proven receiver. */
+    staticReceiver?: ClassInfo;
+    receiverSpecializations?: Map<string, GenericFnInfo>;
     /** Object-literal generic methods (`{ m<T>(x: T) {...} }` and generic
      * arrow/function-expression properties): lowered as plain module
      * functions — `this` inside is fenced (rejectThisInObjectMethod) and the
@@ -147,7 +152,7 @@ export interface GenericInstance {
      * the body builds (a re-demand is same-key recursion: the caller uses
      * the PINNED fallback returnType and returnPinned locks it); "done" once
      * returnType holds the inferred (or pinned) truth. */
-    implicitState?: "lowering" | "done";
+    implicitState?: "lowering" | "done" | "failed";
     /** Same-key recursion observed the fallback return type mid-lowering, so
      * the ABI is locked to it — the return post-pass coerces every return
      * value to the pinned type instead of adopting the inferred one. */
@@ -184,9 +189,9 @@ export declare function isThisParameter(param: ts.ParameterDeclaration): boolean
 export declare function paramShapes(lowerer: Lowerer, params: readonly ts.ParameterDeclaration[], signature?: ts.Signature, blameOf?: (param: ts.ParameterDeclaration, index: number) => ts.Node): ParamShape[];
 /** The fences on a defaulted parameter's body type: it becomes the value
    * arm of the synthesized `T | undefined` ABI union, so it must be a valid
-   * single arm. func and Set ARE valid here: the ABI union's only test is
+   * single arm. Functions, Maps and Sets are valid: the ABI union's test is
    * the prologue's own undefined-tag check (never a user narrowing, which
-   * is what keeps map/set out of general unions), so `runner: Runner =
+   * is what keeps containers out of unions with data siblings), so `runner: Runner =
    * 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;
@@ -297,10 +302,12 @@ export declare function lowerGenericFnValue(lowerer: Lowerer, ref: ts.Expression
 export declare function implicitMonoFile(sf: ts.SourceFile): boolean;
 /** The implicit-type-parameter slots of a JS function-like: parallel to
    * decl.parameters, the param SYMBOL where the slot is a bindable
-   * implicit-any param (identifier-named, no annotation/JSDoc type, not
-   * rest/optional/defaulted, never written), null elsewhere. Null overall
-   * when nothing qualifies — the declaration keeps today's path. */
-export declare function implicitAnyParamSymbolsOf(lowerer: Lowerer, decl: ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction): (ts.Symbol | null)[] | null;
+   * implicit param (identifier-named, broad inferred/JSDoc type, not
+   * rest/optional/defaulted, never written), null elsewhere. Package JS
+   * methods may also specialize class parameters: JSDoc names a nominal
+   * class even when the body accepts other objects with the same members.
+   * Null overall when nothing qualifies — the declaration keeps its ABI. */
+export declare function implicitAnyParamSymbolsOf(lowerer: Lowerer, decl: ts.FunctionDeclaration | ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction, classParams?: boolean): (ts.Symbol | null)[] | null;
 /** True when a `this.method(...)` call targets an implicit npm-static
  * method whose result is settled from its lowered body rather than the
  * checker declaration. Uninitialized-local inference uses this to avoid
@@ -314,6 +321,10 @@ export declare function implicitMethodCallInfersReturn(lowerer: Lowerer, call: t
    * section comment); a same-key re-demand mid-lowering pins the fallback
    * return type. */
 export declare function implicitCallInstance(lowerer: Lowerer, call: ts.CallExpression, info: GenericFnInfo): GenericInstance;
+/** The all-dyn DEFAULT instance — today's compiled body exactly: what a
+   * VALUE reference of an implicit-any function names (indirect calls
+   * carry no per-site types to bind). */
+export declare function implicitDefaultInstance(lowerer: Lowerer, blame: ts.Node, info: GenericFnInfo): GenericInstance;
 /** The implicit-any twin of bindingGenericFnNodeOf, for LOCAL and module
    * bindings alike (`const knownBy = (cmd) => [cmd.name()].concat(...)`
    * inside a method body — commander's _registerCommand shape): the
@@ -423,15 +434,6 @@ export declare function lambdaSignature(lowerer: Lowerer, node: ts.ArrowFunction
         kind: "func";
     };
 };
-/** Does this function's OWN body read `arguments`? Nested plain functions
-   * and methods have their own `arguments` (the walk skips them); arrows
-   * see the enclosing one (the walk descends). Exported for the lowerer's
-   * dynFallbackType: tsgo does not synthesize the `arguments` rest
-   * parameter into inferred signatures (5.9.3 did — its param-count
-   * mismatch was the detector), so the 7 world asks the BODY directly. */
-export declare function bodyReadsArguments(fn: {
-    body?: ts.Node | undefined;
-}): boolean;
 /** Lifts an arrow function / function expression / nested declaration /
    * object-literal shorthand method to a module-level function and yields
    * the `closure` expression creating it. */
@@ -464,13 +466,7 @@ export declare function lowerFilterNarrowCall(lowerer: Lowerer, call: ts.CallExp
  * for-in iterates exactly the keys Object.keys answers. */
 export declare function recordKeysArrayCall(lowerer: Lowerer, receiver: IrExpr, argIr: IrType & {
     kind: "record";
-}, shape: {
-    declaredOrder?: string[];
-    fields: {
-        name: string;
-        type: IrType;
-    }[];
-}, loc: SrcLoc): IrExpr;
+}, shape: import("../../ir/ir.js").IrRecordShape, loc: SrcLoc): IrExpr;
 export declare function lowerFunction(lowerer: Lowerer, decl: ts.FunctionDeclaration): IrFunction | null;
 export declare function lowerRecordFieldCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** The function-like node behind an object-literal generic-method member: