@scriptc/compiler 0.0.35 → 0.1.1

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

@@ -1,10 +1,10 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
 import type { ClassInfo } from "./lower-classes.js";
-import { IrExpr, IrStmt, IrType, SrcLoc } from "../../ir/nodes.js";
+import { IrExpr, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 /** The stream sides of a receiver class: the nearest stream-class
  * ancestor's, or null off the stream hierarchy. */
-export declare function streamSidesOf(L: Lowerer, info: ClassInfo | undefined | null): "r" | "w" | "rw" | null;
+export declare function streamSidesOf(lowerer: Lowerer, info: ClassInfo | undefined | null): "r" | "w" | "rw" | null;
 /** The instance members the stream spoke owns on stream-rooted
  * receivers (the emitter members ride the base chain as usual). */
 export declare const STREAM_API_MEMBERS: ReadonlySet<string>;
@@ -30,17 +30,17 @@ export declare function streamCtorShape(cls: string): {
  * by the emitter spoke BEFORE the program-global table, so a stream's
  * 'data' never collides with a user event named 'data' on a plain
  * emitter. 'error' stays globally forced to the one-%Error tuple. */
-export declare function streamForcedTuple(L: Lowerer, info: ClassInfo | undefined | null, name: string): IrType[] | null;
+export declare function streamForcedTuple(lowerer: Lowerer, info: ClassInfo | undefined | null, name: string): IrType[] | null;
 /** `new Readable(opts?)` and friends — called from lowerNew once the
  * callee resolved to a builtin stream class. */
-export declare function lowerStreamNew(L: Lowerer, expr: ts.NewExpression, info: ClassInfo): IrExpr;
+export declare function lowerStreamNew(lowerer: Lowerer, expr: ts.NewExpression, info: ClassInfo): IrExpr;
 /** `super(options?)` in a class whose direct base chain lands on a
  * runtime stream class: lowers to the stream.init libCall over `this`
  * (the emitted allocation already stamped the subclass vtable and
  * display name; the runtime builds the state block). Options parse
  * exactly like the construction form; overridden underscore methods on
  * the class chain fill callbacks the options leave unset. */
-export declare function lowerStreamSuperCall(L: Lowerer, info: ClassInfo, base: ClassInfo, argNodes: readonly ts.Expression[], thisLocal: {
+export declare function lowerStreamSuperCall(lowerer: Lowerer, info: ClassInfo, base: ClassInfo, argNodes: readonly ts.Expression[], thisLocal: {
     id: string;
 }, loc: SrcLoc, blame: ts.Node): IrStmt[];
 /** `r._read = fn` / `w._write = fn` (and _final/_destroy/_transform/
@@ -56,33 +56,33 @@ export declare function lowerStreamSuperCall(L: Lowerer, info: ClassInfo, base:
  * runtime-stream-rooted receiver (the caller's routes continue);
  * `_writev` and methods outside the receiver's base set keep pointed
  * fences (Node would consume them through unlowered machinery). */
-export declare function lowerStreamUnderscoreAssign(L: Lowerer, expr: ts.BinaryExpression): IrStmt | null;
+export declare function lowerStreamUnderscoreAssign(lowerer: Lowerer, expr: ts.BinaryExpression): IrStmt | null;
 /** `Readable.from(iterable)` — the array-seeded object-entry form:
  * string[] / Buffer[] values (or literals) become a fully-seeded
  * readable delivering one WHOLE chunk per element (Node's objectMode
  * accounting; hwm 1), and a single string/Buffer argument is a
  * one-chunk stream (Node's special case). Called from the method-call
  * chain once the receiver resolved to a stream class value. */
-export declare function lowerStreamStaticCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerStreamStaticCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `const Writable = stream.Writable` — a runtime stream CLASS bound
  * through a namespace member: alias plumbing with no storage (both
  * declaration walks skip it; uses resolve through builtinStreamInfoOf's
  * alias following). Only the five stream class names count — value
  * members (stream.getDefaultHighWaterMark as a value, ...) keep their
  * per-site fences. */
-export declare function streamClassAliasDecl(L: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
+export declare function streamClassAliasDecl(lowerer: Lowerer, nameNode: ts.Node, init: ts.Expression | undefined): boolean;
 /** `finished(...)` / `pipeline(...)` / `getDefaultHighWaterMark(...)`
  * imported from node:stream (named imports, destructured requires, and
  * namespace-member calls all land here). Null for members this spoke
  * does not own — the caller's module-qualified fence speaks. */
-export declare function lowerStreamModuleCall(L: Lowerer, call: ts.CallExpression, bi: {
+export declare function lowerStreamModuleCall(lowerer: Lowerer, call: ts.CallExpression, bi: {
     module: string;
     member: string;
 }, loc: SrcLoc): IrExpr | null;
 /** `recv.<member>(...)` over a stream-rooted receiver. Returns null only
  * for members this spoke does not own. */
-export declare function lowerStreamMethodCall(L: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, info: ClassInfo): IrExpr | null;
-export declare function lowerStreamStateProperty(L: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
+export declare function lowerStreamMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression, info: ClassInfo): IrExpr | null;
+export declare function lowerStreamStateProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression): IrExpr | null;
 /** Property reads on stream-rooted receivers (`r.readableEnded`,
  * `w.destroyed`, ...). Null for names this spoke does not own. */
-export declare function lowerStreamProperty(L: Lowerer, expr: ts.PropertyAccessExpression, info: ClassInfo): IrExpr | null;
+export declare function lowerStreamProperty(lowerer: Lowerer, expr: ts.PropertyAccessExpression, info: ClassInfo): IrExpr | null;