@scriptc/compiler 0.1.4 → 0.1.6

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

@@ -19,22 +19,24 @@ export declare function lowerArrayMethodCall(lowerer: Lowerer, call: ts.CallExpr
    * parameter type). Null when this isn't a tuple slice/map — writers and
    * the rest of the surface keep their fences. */
 export declare function lowerTupleReadMethodCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
-/** An OOB-SAFE indexed read: `xs[i]`
-   * answers the interned `elem | undefined` union — the element when `i`
-   * is an integer in [0, len), JS's property-miss undefined otherwise —
-   * instead of the trap divergence 4 documents for program code.
-   * Package JS is inference-typed, guard-style code (`registeredArguments
-   * .slice(-1)[0]`, commander's last-element probe), and the trap would
-   * fire on working Node idioms; program files keep the documented trap
-   * (their annotations can prove bounds). Existing element unions retag
-   * into the canonical union with an added undefined arm. */
+/** An ordinary indexed read: values retain their element type, while
+ * holes, missing properties, and present undefined yield undefined. */
 export declare function lowerSafeIndexRead(lowerer: Lowerer, arr: IrExpr & {
     type: {
         kind: "array";
     };
 }, index: IrExpr, loc: SrcLoc): IrExpr | null;
+/** Fuse only our own f64-array read helper with immediate ToNumber.
+ * Reuse its arguments verbatim so the receiver and index still evaluate
+ * exactly once, in order, before the read. Do not specialize user calls,
+ * union-element arrays, or optional values stored in locals. */
+export declare function tryLowerNumericIndexRead(lowerer: Lowerer, operand: IrExpr, loc: SrcLoc): IrExpr | null;
 /** Backward-compatible name for the npm-static probe path. */
 export declare const lowerNpmStaticSafeIndexRead: typeof lowerSafeIndexRead;
+/** The Array constructor's element and count forms, shared by calls and new. */
+export declare function lowerArrayConstructor(lowerer: Lowerer, expr: ts.CallExpression | ts.NewExpression, args: readonly ts.Expression[]): IrExpr;
+/** `Array.of` creates an array of its arguments, including a lone number. */
+export declare function lowerArrayOfCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `Array.from({ length: n }, mapfn)` — the counted-generation idiom — on
    * THE stdlib Array global. The source must be an OBJECT LITERAL whose
    * single property is `length` (the shape the idiom always spells; the
@@ -44,8 +46,10 @@ export declare const lowerNpmStaticSafeIndexRead: typeof lowerSafeIndexRead;
    * checker's own `unknown` for it — and pushing each result. The loop
    * bound is `i <= n - 1`, which IS ToLength for the finite lengths that
    * terminate (fractional lengths truncate, negative/NaN produce an empty
-   * array — Node-exact). Every other Array.from shape (arrays, iterables,
-   * no mapper) keeps the fence. Null when the callee isn't an
+   * array — Node-exact). Array inputs copy through the iterator's indexed
+   * values, including holes as present undefined, and may map each value.
+   * Set inputs copy their values; strings iterate by code point and may map.
+   * Other iterable shapes keep the fence. Null when the callee isn't an
    * Array-static access. */
 export declare function lowerArrayFromCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** `Array.from(s)` / `[...s]` on a STRING: the code-point split into a