@scriptc/compiler 0.2.1 → 0.2.2

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;

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";
@@ -2808,6 +2808,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 +2904,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 +2939,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 },
@@ -3314,7 +3322,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 +3378,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 +3763,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);
     }
@@ -5351,8 +5370,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
@@ -5546,7 +5565,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 +5920,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]