@scriptc/compiler 0.0.3 → 0.0.5

package/dist/frontend/lowering/lowerer.d.ts

@@ -33,6 +33,10 @@ export type WidthLift = {
     how: "width";
 } | {
     how: "arr";
+} | {
+    how: "tupleArr";
+} | {
+    how: "emptyArr";
 } | {
     how: "objWidth";
 } | {
@@ -191,6 +195,12 @@ export interface LowerOptions {
      * resolution walk and CJS named-import link check): the program
      * compiles to that startup crash. */
     startupCrash?: StartupCrash | null;
+    /** LIBRARY mode's reachability roots: the profile-mapped exports of the
+     * entry module. Executable builds root at the entry's top level alone
+     * (an unreferenced export dead-strips); a library's exports are called from
+     * OUTSIDE the graph, so discovery seeds them alongside the init
+     * bodies. Names are the entry file's unqualified declaration names. */
+    libRoots?: readonly string[];
 }
 /** The Lowerer's pass configuration (see lowerToIr). */
 export interface LowererMode {
@@ -436,6 +446,12 @@ export declare class Lowerer {
     /** Synthetic URLSearchParams.forEach loop functions, interned per
      * callback arity/return — Map's pattern over the sp index walk. */
     readonly spHofHelpers: Map<string, string>;
+    /** The primitive-constructor VALUES (`String`/`Number`/`Boolean` as
+     * bare identifiers — CLI option tables store and compare them): one
+     * synthesized coercion function per constructor per program, interned
+     * here by name so every reference is the SAME zero-capture closure and
+     * `opt.type === String` is JS identity (see primitiveCtorClosure). */
+    readonly primitiveCtorFns: Map<string, string>;
     /** Optional-chain lowering state. While a chain body lowers, the guarded
      * receiver NODE reads as a chainRecv (typed by the narrowed arm) instead
      * of re-lowering, its checker type reads non-nullish (typeOf), and the
@@ -672,6 +688,17 @@ export declare class Lowerer {
      * point for deferred collection diagnostics: resolving a reference to a
      * broken declaration reports what collection deferred. */
     resolveValueSymbol(ident: ts.Identifier): ts.Symbol | null;
+    /** The default-snapshot storage symbol a DEFAULT-import alias chain
+     * lands on, or null. A mutable entity-name default (`export default
+     * someLet`) registers its Node-semantics snapshot global under the
+     * exporter's default ALIAS symbol; the checker's getAliasedSymbol
+     * resolves through that symbol to the live let, so this walk follows
+     * the default hops syntactically — default import clauses, `{ default
+     * as x }` specifiers, `export { default } from` re-exports — and stops
+     * at the first default symbol carrying registered storage. Local
+     * `export { x as default }` specifiers (no module specifier) are LIVE
+     * bindings in Node and fall through to ordinary alias resolution. */
+    private defaultSnapshotSymbolOf;
     /** A module's CJS export-table member symbol by NAME (the checker's
      * module-symbol exports map — present in tsgo even where no expando
      * property symbol exists at the attachment/use sites). */
@@ -734,6 +761,15 @@ export declare class Lowerer {
     collectNpmImports(parts: FileParts[]): void;
     collectJsonImports(parts: FileParts[]): void;
     run(): LowerResult;
+    /** The unregistered-class type sweep (run()'s last step before the
+     * module assembles): every `{kind:"object"}` TYPE naming a class with
+     * no registered ClassInfo is rewritten IN PLACE to the f64 dummy.
+     * classval types are exempt (they emit the class-independent
+     * `ScrClassObj *` — inert-but-valid storage, the validator's own
+     * stance), and only type objects rewrite — node-level classNames
+     * (`new`, upcasts) cannot reach here (their lowerings fence without a
+     * registered class), so the validator still backstops those. */
+    sanitizeUnregisteredClassTypes(roots: unknown[]): void;
     /** True when `t` (recursively) names a class instance type with no
      * registered ClassInfo — the shape of a JS class whose collection fenced.
      * Used by run()'s global pruning; shapes/unions recurse with a seen-set
@@ -756,7 +792,7 @@ export declare class Lowerer {
      * demand-driven) and lifted lambdas lower inline with their enclosing
      * body; both fire edges through the same hooks and are not units
      * themselves. */
-    discover(): Set<string>;
+    discover(extraRoots?: readonly string[]): Set<string>;
     /** Discovery hook (see discover): fires when lowering resolves a
      * reference to a lowerable body. Inert in the emit pass. */
     noteEdge(name: string): void;
@@ -904,6 +940,9 @@ export declare class Lowerer {
      *               copy loop, arrayWidthHelper)
      * Null when the pair isn't in the relation — callers keep their fences. */
     widthLiftPlan(src: IrType, dst: IrType): WidthLift | null;
+    /** True for the unit-only element types (`(null | undefined)[]`, the
+     * `readonly []` mapping): a union whose every arm is a unit. */
+    unitOnlyElem(t: IrType): boolean;
     /** The build side of widthLiftPlan: the IrExpr converting `value` into
      * `dst` under a plan the caller validated. Interns whatever helpers the
      * lift needs (planned first, so the interns cannot fail — a failure here
@@ -932,6 +971,8 @@ export declare class Lowerer {
     } | {
         absent: true;
         utag: number;
+    } | {
+        absentDyn: true;
     }> | null;
     recordWidthHelper(fromId: string, toId: string, loc: SrcLoc): string | null;
     /** Interned `%arr.width.<n>(a)` — the per-element copy loop over
@@ -947,6 +988,16 @@ export declare class Lowerer {
     tupleArrayWidthHelper(fromId: string, toT: IrType & {
         kind: "array";
     }, loc: SrcLoc): string | null;
+    /** Interned `%arr.empty.<n>(a)` — the EMPTY-array lift's build side: a
+     * unit-only-element array reshapes into any data-element array by
+     * answering a FRESH empty array, after a runtime non-empty trap (a
+     * genuinely inhabited `(null | undefined)[]` cannot reshape — the
+     * catchable-TypeError stance every checked extraction takes). */
+    emptyArrayLiftHelper(fromT: IrType & {
+        kind: "array";
+    }, toT: IrType & {
+        kind: "array";
+    }, loc: SrcLoc): string;
     arrayWidthHelper(fromT: IrType & {
         kind: "array";
     }, toT: IrType & {
@@ -1145,6 +1196,17 @@ export declare class Lowerer {
      * impossible value flow on). Null when the target isn't a non-unit arm
      * of the union — those uses keep their erasure/fences. */
     narrowedArmHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
+    /** The DEFERRED-INIT field read (`stream!: T` assigned past the
+     * constructor's top level — the slot is `T | undefined`): interned
+     * `%deferred.read.<n>(u)` extracting the declared type. SCALAR arms
+     * whose JS-undefined behavior a unit default reproduces read that
+     * default — bool false (conditions are exact: undefined and false are
+     * both falsy; only printing/strict-equality could tell) and f64 NaN
+     * (arithmetic and conditions exact) — while string and REF arms keep
+     * the checked-extraction TRAP: JS itself TypeErrors the first member
+     * use of such an undefined, so the catchable TypeError at the read is
+     * the same failure, named earlier (SEMANTICS.md). */
+    deferredReadHelper(fromId: string, target: IrType, loc: SrcLoc): string | null;
     /** True when a static value can become ONE island value: jsval itself,
      * anything boundary-safe (the deep JSON marshal), a record whose fields
      * all can (built as an island OBJECT literal, field by field), or an
@@ -1467,6 +1529,14 @@ export declare class Lowerer {
      * through arrows (function expressions/declarations reset `this` in JS;
      * their bodies never see an enclosing method's binding). */
     resolveThis(): IrLocal | null;
+    /** READ-ONLY twin of resolveLocal for PROBES (isIslandExpr): answers
+     * the nearest binding entry without boxing, threading, or predeclaring.
+     * resolveKey mutates capture state as a side effect, and a speculative
+     * island-ness query through a context that takes no captures (a plain
+     * declared function between the origin and the reference) was an ICE —
+     * the REAL lowering path still resolves (and diagnoses) the reference
+     * itself. */
+    peekLocal(ident: ts.Identifier): IrLocal | null;
     resolveKey(symbol: ts.Symbol, blame?: ts.Node): IrLocal | null;
     isSelfReference(ident: ts.Identifier): boolean;
     lowerStmts(stmts: readonly ts.Statement[]): IrStmt[];
@@ -1625,7 +1695,7 @@ export declare class Lowerer {
     rejectComptimeCaptures(cb: ts.ArrowFunction | ts.FunctionExpression): void;
     comptimeValueToIr(value: unknown, expected: IrType, path: string, blame: ts.Node): IrExpr;
     isConsoleLog(call: ts.CallExpression): boolean;
-    consoleCallMember(call: ts.CallExpression): "log" | "error" | "warn" | null;
+    consoleCallMember(call: ts.CallExpression): "log" | "info" | "debug" | "error" | "warn" | null;
     builtinImportOf(ident: ts.Identifier): {
         module: string;
         member: string;