@scriptc/compiler 0.2.1 → 0.2.3

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

@@ -34,7 +34,7 @@ export declare function lowerArrayConstructor(lowerer: Lowerer, expr: ts.CallExp
 export declare function lowerArrayOfCall(lowerer: Lowerer, call: ts.CallExpression, access: ts.PropertyAccessExpression): IrExpr | null;
 /** Mapper-less checked Array.from: acquire once, then step through emitted
  * property and call dispatch so native class iterators retain their methods. */
-export declare function lowerCheckedArrayFrom(lowerer: Lowerer, source: IrExpr, loc: SrcLoc, mapper?: IrExpr, receiver?: IrExpr, numeric?: boolean): Extract<IrExpr, {
+export declare function lowerCheckedArrayFrom(lowerer: Lowerer, source: IrExpr, loc: SrcLoc, mapper?: IrExpr, receiver?: IrExpr, numeric?: boolean, iterable?: IrExpr): Extract<IrExpr, {
     kind: "seqExpr";
 }>;
 export declare function lowerArrayFromValue(lowerer: Lowerer, loc: SrcLoc): IrExpr;
@@ -49,7 +49,8 @@ export declare function lowerArrayFromValue(lowerer: Lowerer, loc: SrcLoc): IrEx
    * terminate (fractional lengths truncate, negative/NaN produce an empty
    * 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.
+   * Map and Set inputs consume live values or entries and may map them.
+   * 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;
@@ -225,6 +226,9 @@ export declare function lowerSetSeedNew(lowerer: Lowerer, node: ts.Expression, s
 export declare function lowerMapSeedNew(lowerer: Lowerer, argNode: ts.Expression, mapT: IrType & {
     kind: "map";
 }): IrExpr | null;
+export declare function mapFromSeedValue(lowerer: Lowerer, seed: IrExpr, mapT: IrType & {
+    kind: "map";
+}): IrExpr | null;
 /** `Object.keys/values/entries` over an INDEX-SIGNATURE (overflow-carrying)
    * record shape: declared fields answer first from the compile-time field
    * list (declaration order, undefined-valued fields skipped — exactly the

package/dist/frontend/lowering/lower-containers.js

@@ -6,7 +6,7 @@ import { InternalCompilerError } from "../../errors.js";
  * record operations. */
 import * as ts from "../ts7/adapter.js";
 import { BOOL, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/ir.js";
-import { ARRAY_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS } from "./surfaces.js";
+import { ARRAY_METHODS, COLLECTION_ITERATOR_METHODS, MAP_METHODS, SET_COMBINE_METHODS, SET_METHODS } from "./surfaces.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { forOfVarTarget, lowerDestructuringAssign } from "./lower-stmts.js";
 import { isJsSourceFile, locOf } from "../program.js";
@@ -18,6 +18,7 @@ import { dynUndefinedExpr, newFnCtx, nodeThrowExpr } from "./lowerer.js";
 import { boolLit, countedFor, numLit, strLit, varRef } from "../../ir/build.js";
 import { defaultAfterUndefined, lowerPositionArgument, lowerStaticallyUndefinedArgument, positionNumber } from "./optional-arguments.js";
 import { lowerArrayCopyWithin, lowerArrayFill } from "./array-indexed-mutation.js";
+import { collectionInput, collectionDestinationMatches, ingestCollection, lowerCollectionInput } from "./collection-ingestion.js";
 /** Object() and new Object() preserve known object inputs. Primitive
  * boxing and unproven checked-dynamic values retain their refusal. */
 export function lowerObjectConstructor(lowerer, args, loc) {
@@ -2808,6 +2809,14 @@ export function lowerArrayConstructor(lowerer, expr, args) {
         lowerer.noLowering("Array constructor with spread arguments", expr);
     }
     let result = lowerer.mapTypeOf(lowerer.typeOf(expr));
+    // Constructors without a concrete element layout keep their checked
+    // reference. Known element forms retain native arrays, including their
+    // existing sparse storage and indexed property contracts.
+    if (!lowerer.dynamic && isJsSourceFile(expr.getSourceFile()) &&
+        (result?.kind !== "array" || result.elem.kind === "dyn")) {
+        return { kind: "dynCall", callee: { kind: "libCall", fn: "dyn.arrayConstructor", args: [], type: DYN, loc },
+            calleeName: "Array", args: args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), type: DYN, loc };
+    }
     if (result?.kind !== "array") {
         const contextual = lowerer.checker.getContextualType(expr);
         if (contextual)
@@ -2896,7 +2905,7 @@ export function lowerArrayOfCall(lowerer, call, access) {
 }
 /** Mapper-less checked Array.from: acquire once, then step through emitted
  * property and call dispatch so native class iterators retain their methods. */
-export function lowerCheckedArrayFrom(lowerer, source, loc, mapper, receiver, numeric = false) {
+export function lowerCheckedArrayFrom(lowerer, source, loc, mapper, receiver, numeric = false, iterable) {
     const iterator = lowerer.declareHiddenLocal("%fromIterator", DYN);
     const next = lowerer.declareHiddenLocal("%fromNext", DYN);
     const step = lowerer.declareHiddenLocal("%fromStep", DYN);
@@ -2931,7 +2940,7 @@ export function lowerCheckedArrayFrom(lowerer, source, loc, mapper, receiver, nu
                             { kind: "exprStmt", expr: nodeThrowExpr(1, "", "Array.from mapper is not a function", DYN, loc), loc },
                         ], loc },
                 ], loc }] : []),
-        { kind: "varDecl", localId: iterator.id, init: { kind: "libCall", fn: "dyn.iteratorResult", args: [{ kind: "libCall", fn: "dyn.arrayFromIterator", args: [source], type: DYN, loc }], type: DYN, loc }, loc },
+        { kind: "varDecl", localId: iterator.id, init: { kind: "libCall", fn: "dyn.iteratorResult", args: [{ kind: "libCall", fn: iterable ? "dyn.iterator" : "dyn.arrayFromIterator", args: iterable ? [source, iterable] : [source], type: DYN, loc }], type: DYN, loc }, loc },
         { kind: "varDecl", localId: next.id, init: get(varRef(iterator.id, DYN, loc), "next"), loc },
         { kind: "varDecl", localId: out.id, init: { kind: "dynArrLit", elems: [], type: DYN, loc }, loc },
         { kind: "varDecl", localId: done.id, init: boolLit(false, loc), loc },
@@ -2983,7 +2992,8 @@ export function lowerArrayFromValue(lowerer, loc) {
    * terminate (fractional lengths truncate, negative/NaN produce an empty
    * 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.
+   * Map and Set inputs consume live values or entries and may map them.
+   * 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 function lowerArrayFromCall(lowerer, call, access) {
@@ -3017,6 +3027,26 @@ export function lowerArrayFromCall(lowerer, call, access) {
         return { kind: "call", callee: name, args: [0, 1, 2].map((i) => args[i]
                 ? lowerer.lowerExprExpecting(args[i], DYN) : dynUndefinedExpr(loc)), type: DYN, loc };
     }
+    if ((args.length === 1 || args.length === 2) && !args.some(ts.isSpreadElement)) {
+        const input = collectionInput(lowerer, args[0]);
+        if (input) {
+            const source = lowerCollectionInput(lowerer, input);
+            if (source) {
+                if (args.length === 1) {
+                    fenceProducedArrayElem(lowerer, call, "'Array.from(collection)'", input.element);
+                    return ingestCollection(lowerer, input, source, { kind: "array", elem: input.element }, loc);
+                }
+                const callback = hofCallbackArg(lowerer, args[1], [input.element], arrayOf(input.element));
+                if (callback.arity > 2)
+                    lowerer.noLowering("Array.from mapper with an array parameter", args[1]);
+                if (callback.fnArg.type.ret.kind === "void" || callback.fnArg.type.ret.kind === "func")
+                    lowerer.badType(call, lowerer.typeOf(call));
+                const element = callbackArrayElem(lowerer, call, callback.fnArg.type.ret);
+                fenceProducedArrayElem(lowerer, call, "'Array.from(collection, mapper)'", element);
+                return ingestCollection(lowerer, input, source, { kind: "array", elem: element }, loc, callback.fnArg);
+            }
+        }
+    }
     // MAPPER-LESS `Array.from({ length: n })` (usually with an explicit
     // type argument — the pMap results-array idiom): a length-n array of
     // ABSENT slots, filled by index before any read. Union elements with
@@ -3314,7 +3344,7 @@ export function lowerMapMethodCall(lowerer, call, access) {
     if (lowerer.chainBlocked(access, call))
         return null;
     const name = access.name.text;
-    if (!MAP_METHODS.has(name) && !MAP_ITER_METHODS.has(name))
+    if (!MAP_METHODS.has(name))
         return null;
     let receiverIr = lowerer.mapTypeOf(lowerer.typeOf(access.expression));
     let probedUntyped = false;
@@ -3370,31 +3400,39 @@ export function lowerMapMethodCall(lowerer, call, access) {
     if (name === "clear") {
         return { kind: "mapIntrinsic", method: "clear", receiver, args: [], type: VOID, loc };
     }
-    if (MAP_ITER_METHODS.has(name)) {
+    if (COLLECTION_ITERATOR_METHODS.has(name)) {
         return lowerMapIterDrainCall(lowerer, call, receiver, receiverIr, name);
     }
     // forEach
     return lowerMapForEachCall(lowerer, call, receiver, receiverIr, probedUntyped);
 }
-/** The iterator methods the lowering DOES cover — in exactly one context. */
-const MAP_ITER_METHODS = new Set(["keys", "values", "entries"]);
+/** Stored collection iterators retain the native collection by reference. The
+ * checked-value runtime supplies the live cursor without embedding an engine. */
+function lowerCollectionIteratorCall(lowerer, call, receiver, method) {
+    const access = call.expression;
+    if (!ts.isPropertyAccessExpression(access))
+        throw new InternalCompilerError("collection iterator requires a member call");
+    const boxed = lowerer.coerceInto(access.expression, receiver, DYN);
+    const result = lowerDynDispatchMethodCall(lowerer, call, access, boxed, false);
+    if (!result)
+        throw new InternalCompilerError(`missing collection iterator dispatch: ${method}`);
+    return result;
+}
 /** `[...m.keys()]` / `[...m.values()]` / `[...m.entries()]` — the iterator
-   * methods, lowered ONLY as the operand of a spread inside an array
+   * methods use an optimized drain as the operand of a spread inside an array
    * literal, where JS drains the iterator on the spot. The call desugars to
    * a direct call of a synthetic drain function whose loop walks the same
    * iteration primitives as the forEach desugar and pushes each live entry
    * into a fresh array — key, value, or `[K, V]` tuple record per method.
    * No user code runs mid-drain (and nothing here mutates the map), so no
    * compaction can shift indices: the enter/exit bracket is unnecessary and
-   * the snapshot IS what JS's immediate drain observes. Every other context
-   * (storing the iterator, .next(), passing it along) would need a real
-   * iterator value — fenced with the spread spelling as the hint. */
+   * the snapshot IS what JS's immediate drain observes. Other contexts keep
+   * a live iterator through the native checked-value runtime. */
 function lowerMapIterDrainCall(lowerer, call, receiver, mapT, method) {
     const loc = locOf(call);
     const inArraySpread = ts.isSpreadElement(call.parent) && ts.isArrayLiteralExpression(call.parent.parent);
-    if (!inArraySpread) {
-        lowerer.noLowering(`.${method}() outside an immediate array spread`, call, `iterator objects have no lowering — drain it into an array where it is made: [...m.${method}()]`);
-    }
+    if (!inArraySpread)
+        return lowerCollectionIteratorCall(lowerer, call, receiver, method);
     // The pushed element type. For entries the checker's own element type —
     // the [K, V] tuple behind MapIterator<[K, V]> — carries the interned
     // tuple shape the surrounding literal will intern too.
@@ -3747,6 +3785,9 @@ export function lowerSetMethodCall(lowerer, call, access) {
     if (name === "forEach" && call.arguments.length !== 1) {
         lowerer.noLowering(`.forEach with ${call.arguments.length} arguments`, call, "the thisArg parameter has no lowering — use an arrow function");
     }
+    if (COLLECTION_ITERATOR_METHODS.has(name)) {
+        return lowerCollectionIteratorCall(lowerer, call, receiver, name);
+    }
     if (SET_COMBINE_METHODS.has(name)) {
         return lowerSetCombineCall(lowerer, call, name, receiver, receiverIr);
     }
@@ -5342,7 +5383,14 @@ export function lowerSetSeedNew(lowerer, node, setT) {
         const elems = node.elements.map((element) => lowerer.lowerCollectionKey(element, setT.elem));
         return { kind: "setNew", seed: { kind: "arrayLit", elems, type: arrayOf(setT.elem), loc }, type: setT, loc };
     }
-    const declared = lowerer.mapTypeOf(lowerer.typeOf(node));
+    const input = collectionInput(lowerer, node);
+    if (input && collectionDestinationMatches(lowerer, input, setT)) {
+        const source = lowerCollectionInput(lowerer, input);
+        if (source)
+            return ingestCollection(lowerer, input, source, setT, loc);
+    }
+    const seedType = lowerer.typeOf(node);
+    const declared = lowerer.mapTypeOf(seedType);
     const scalar = setT.elem.kind === "f64" || setT.elem.kind === "string";
     let source = !scalar && (declared?.kind === "array" || declared?.kind === "record")
         ? lowerer.lowerCollectionKey(node, declared)
@@ -5351,8 +5399,8 @@ export function lowerSetSeedNew(lowerer, node, setT) {
         (source.type.kind === "dyn" || source.type.kind === "jsval")) {
         source = lowerer.coerceInto(node, source, STRING);
     }
-    if (source.type.kind === "dyn" && setT.elem.kind === "dyn") {
-        return { kind: "dynCheck", value: { kind: "libCall", fn: "dyn.nativeSetNew", args: [source], type: DYN, loc }, type: setT, loc };
+    if (setT.elem.kind === "dyn" && lowerer.dynConvertible(source.type)) {
+        return { kind: "dynCheck", value: { kind: "libCall", fn: "dyn.nativeSetNew", args: [lowerer.coerceInto(node, source, DYN)], type: DYN, loc }, type: setT, loc };
     }
     if (declared?.kind === "array" && typeEquals(declared.elem, setT.elem)) {
         // Preserve the existing checked scalar-iterable bridge. Reference
@@ -5481,10 +5529,18 @@ export function lowerMapSeedNew(lowerer, argNode, mapT) {
             ], true) };
         return mapFromSeedValue(lowerer, lowerer.lowerArrayLiteral(argNode, { kind: "array", elem: tuple }), mapT);
     }
+    const input = collectionInput(lowerer, argNode);
+    if (input) {
+        if (!collectionDestinationMatches(lowerer, input, mapT))
+            return null;
+        const source = lowerCollectionInput(lowerer, input);
+        if (source)
+            return ingestCollection(lowerer, input, source, mapT, locOf(argNode));
+    }
     const seed = lowerer.lowerExpr(argNode);
     return mapFromSeedValue(lowerer, seed, mapT);
 }
-function mapFromSeedValue(lowerer, seed, mapT) {
+export function mapFromSeedValue(lowerer, seed, mapT) {
     const loc = seed.loc;
     if (isUnitType(seed.type)) {
         return defaultAfterUndefined(seed, { kind: "mapNew", type: mapT, loc });
@@ -5546,7 +5602,7 @@ function mapFromSeedValue(lowerer, seed, mapT) {
         return { kind: "call", callee: name, args: [seed], type: mapT, loc };
     }
     if (seed.type.kind === "dyn" || seed.type.kind === "array" &&
-        (seed.type.elem.kind === "dyn" || seed.type.elem.kind === "array")) {
+        !(seed.type.elem.kind === "record" && lowerer.shapes.get(seed.type.elem.shapeId)?.tuple)) {
         const key = `checked-seed:${typeKey(mapT)}`;
         let name = lowerer.mapHofHelpers.get(key);
         if (!name) {
@@ -5901,6 +5957,9 @@ function lowerTypedObjectFromEntriesCall(lowerer, call, callee) {
     const argIr = lowerer.mapTypeOf(lowerer.typeOf(argNode));
     if (argIr?.kind !== "array")
         return null;
+    const represented = tryLowerExpression(lowerer, argNode);
+    if (represented && !typeEquals(represented.type, argIr))
+        return null;
     // `Object.fromEntries(rows)` over a `string[][]` VALUE — the env-line
     // idiom (`envArray.map((env) => env.split('='))`). The checker has no
     // tuple to type here (string[] misses the lib's [PropertyKey, T]