@scriptc/compiler 0.2.2 → 0.2.3

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

@@ -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

@@ -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) {
@@ -2991,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) {
@@ -3025,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
@@ -5361,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)
@@ -5500,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 });