@scriptc/compiler 0.2.3 → 0.2.4

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";
@@ -3386,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: [
@@ -5391,7 +5399,7 @@ export function lowerSetSeedNew(lowerer, node, setT) {
     }
     const seedType = lowerer.typeOf(node);
     const declared = lowerer.mapTypeOf(seedType);
-    const scalar = setT.elem.kind === "f64" || setT.elem.kind === "string";
+    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);
@@ -5448,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);
@@ -5569,37 +5577,7 @@ export 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)) {