@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -23,6 +23,7 @@ import { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
 import { rejectStaticThis } from "./static-this.js";
+import { staticForkString } from "../fork-target.js";
 /** The KEY symbol behind a LATE-BOUND (`__@name@id`) property: resolved
    * from the argument of the element-access assignment that declared it
    * (`this[kLimit] = v` — the declaration list holds the BinaryExpression
@@ -4546,8 +4547,21 @@ export function lowerNew(lowerer, expr) {
         }
         if (symbol && symbol.name === "URL" && lowerer.isStdlibSymbol(symbol)) {
             const args = expr.arguments ?? [];
+            if (args.length === 2) {
+                const folded = staticForkString(lowerer.program, expr);
+                if (folded === null) {
+                    lowerer.noLowering("new URL with a runtime-valued base", expr, "a relative literal or statically resolvable template against import.meta.url compiles", symbol);
+                }
+                return {
+                    kind: "libCall",
+                    fn: "url.new",
+                    args: [{ kind: "strLit", value: folded, type: STRING, loc }],
+                    type: URL_T,
+                    loc,
+                };
+            }
             if (args.length !== 1) {
-                lowerer.noLowering(`new URL with ${args.length} argument${args.length === 1 ? "" : "s"}`, expr, "one absolute-URL string is the supported form (resolve relative inputs against a base yourself)", symbol);
+                lowerer.noLowering(`new URL with ${args.length} argument${args.length === 1 ? "" : "s"}`, expr, "one absolute-URL string, or a static relative input against import.meta.url, is supported", symbol);
             }
             const input = lowerer.lowerExprExpecting(args[0], STRING);
             return { kind: "libCall", fn: "url.new", args: [input], type: URL_T, loc };
@@ -4761,12 +4775,11 @@ export function lowerNew(lowerer, expr) {
             }
             lowerer.badType(expr, tsType);
         }
-        // `new Set<T>()`: Map's sibling. The SEEDED form lowers for any
-        // T[]-typed argument — literal or variable, T already a legal
-        // element type — as construct + bulk add (duplicates collapse,
-        // insertion order preserved, exactly JS). Non-array seeds (another
-        // Set, general iterables) keep the fence. Unsupported element types
-        // are named specifically.
+        // `new Set<T>()`: Map's sibling. The SEEDED form lowers for arrays
+        // and fixed tuples of legal elements — literal or variable — as
+        // construct + bulk add (duplicates collapse, insertion order
+        // preserved, exactly JS). Other iterables keep the fence.
+        // Unsupported element types are named specifically.
         // `new WeakMap()` / `new WeakSet()` in JAVASCRIPT sources: no weak
         // container exists in the value model, but harness code constructs
         // one unconditionally and touches it only on paths tests don't
@@ -4816,6 +4829,24 @@ export function lowerNew(lowerer, expr) {
                         // Any other lowered kind falls through to the named fence
                         // below — never a mistyped seed into the validator.
                     }
+                    // Fixed tuples use record storage, not T[] storage. Snapshot
+                    // their legal elements into an array before bulk insertion;
+                    // the helper takes the tuple as one argument, so an effectful
+                    // seed expression is evaluated exactly once.
+                    if (argIr?.kind === "record") {
+                        const shape = lowerer.shapes.get(argIr.shapeId);
+                        if (shape?.tuple && shape.fields.every((field) => typeEquals(field.type, mapped.elem))) {
+                            const seedType = { kind: "array", elem: mapped.elem };
+                            const helper = lowerer.tupleArrayWidthHelper(argIr.shapeId, seedType, loc);
+                            if (helper) {
+                                const tuple = lowerer.lowerExpr(argNode);
+                                if (typeEquals(tuple.type, argIr)) {
+                                    const seed = { kind: "call", callee: helper, args: [tuple], type: seedType, loc };
+                                    return { kind: "setNew", seed, type: mapped, loc };
+                                }
+                            }
+                        }
+                    }
                 }
             }
             // JavaScript's identity-Set idiom: `new Set([setTimeout, atob,
@@ -4840,7 +4871,7 @@ export function lowerNew(lowerer, expr) {
                 }
             }
             if ((expr.arguments?.length ?? 0) > 0) {
-                lowerer.noLowering("new Set(values)", expr, "construct the Set empty and add() each value — only an array of " +
+                lowerer.noLowering("new Set(values)", expr, "construct the Set empty and add() each value — only an array or fixed tuple of " +
                     "already-legal elements (string or number) seeds a Set");
             }
             if (mapped?.kind === "set")