@scriptc/compiler 0.2.2 → 0.2.4

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

@@ -5,7 +5,7 @@ import { InternalCompilerError } from "../../errors.js";
  * methods with Node-exact forEach desugaring, iterator helpers, and indexed
  * 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 { BOOL, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, funcOf, isPrimitiveCollectionKey, isRefCounted, isSupportedArrayElem, isSupportedIndexValue, isUnitType, typeEquals } from "../../ir/ir.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";
@@ -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
@@ -3364,6 +3386,14 @@ export function lowerMapMethodCall(lowerer, call, access) {
         const v = receiverIr.value.kind === "dyn"
             ? lowerer.lowerCollectionKey(call.arguments[1], receiverIr.value)
             : lowerer.lowerExprExpecting(call.arguments[1], receiverIr.value);
+        // A discarded set result needs no second receiver read or identity
+        // owner. Keep the ordinary operand order: receiver, key, then value.
+        let parent = call.parent;
+        while (ts.isParenthesizedExpression(parent))
+            parent = parent.parent;
+        if (ts.isExpressionStatement(parent)) {
+            return { kind: "mapIntrinsic", method: "set", receiver, args: [k, v], type: VOID, loc };
+        }
         const slot = lowerer.declareHiddenLocal("%mapSetReceiver", receiver.type);
         const ref = varRef(slot.id, receiver.type, loc);
         return { kind: "seqExpr", stmts: [
@@ -5361,8 +5391,15 @@ 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 scalar = setT.elem.kind === "f64" || setT.elem.kind === "string";
+    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 = isPrimitiveCollectionKey(setT.elem, setT.elem.kind === "union" ? lowerer.unions.get(setT.elem.unionId)?.arms : undefined);
     let source = !scalar && (declared?.kind === "array" || declared?.kind === "record")
         ? lowerer.lowerCollectionKey(node, declared)
         : lowerer.lowerExpr(node);
@@ -5419,7 +5456,7 @@ function setFromSeedValue(lowerer, source, setT, missing) {
     }
     let seed;
     if (source.type.kind === "set" && typeEquals(source.type, setT)) {
-        seed = { kind: "setIntrinsic", method: "toArray", receiver: source, args: [], type: arrayOf(setT.elem), loc };
+        return { kind: "setIntrinsic", method: "clone", receiver: source, args: [], type: setT, loc };
     }
     else if (source.type.kind === "string" && setT.elem.kind === "string") {
         seed = strCharsCall(lowerer, source, loc);
@@ -5500,10 +5537,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 });
@@ -5532,37 +5577,7 @@ function mapFromSeedValue(lowerer, seed, mapT) {
     if (seed.type.kind === "map") {
         if (!typeEquals(seed.type, mapT))
             return null;
-        const key = `copy:${typeKey(mapT)}`;
-        let name = lowerer.mapHofHelpers.get(key);
-        if (!name) {
-            name = `%map.copy.${lowerer.mapHofHelpers.size}`;
-            lowerer.mapHofHelpers.set(key, name);
-            const source = varRef("source.0", mapT, loc);
-            const target = varRef("target.0", mapT, loc);
-            const index = varRef("i.0", F64, loc);
-            const read = (method, type) => ({
-                kind: "mapIntrinsic", method, receiver: source, args: method === "iterCount" ? [] : [index], type, loc,
-            });
-            lowerer.liftedFns.push({
-                name, params: [{ localId: "source.0", name: "source", type: mapT }], returnType: mapT,
-                locals: [
-                    { id: "source.0", name: "source", type: mapT, mutable: false },
-                    { id: "target.0", name: "target", type: mapT, mutable: false },
-                    { id: "i.0", name: "i", type: F64, mutable: true },
-                ],
-                body: [
-                    { kind: "varDecl", localId: "target.0", init: { kind: "mapNew", type: mapT, loc }, loc },
-                    countedFor(loc, read("iterCount", F64), () => [{
-                            kind: "if", cond: read("iterLive", BOOL), then: [{ kind: "exprStmt", expr: {
-                                        kind: "mapIntrinsic", method: "set", receiver: target,
-                                        args: [read("iterKey", mapT.key), read("iterValue", mapT.value)], type: VOID, loc,
-                                    }, loc }], else_: null, loc,
-                        }]),
-                    { kind: "return", value: target, loc },
-                ], loc,
-            });
-        }
-        return { kind: "call", callee: name, args: [seed], type: mapT, loc };
+        return { kind: "mapIntrinsic", method: "clone", receiver: seed, args: [], type: mapT, loc };
     }
     if (seed.type.kind === "dyn" || seed.type.kind === "array" &&
         !(seed.type.elem.kind === "record" && lowerer.shapes.get(seed.type.elem.shapeId)?.tuple)) {