@scriptc/compiler 0.0.11 → 0.0.13

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

@@ -98,7 +98,7 @@ export declare function hoistVarBinding(L: Lowerer, symbol: ts.Symbol, nameNode:
    * such reads `undefined`, never a TDZ error, so the hoisted slot must
    * hold `undefined` from function entry — which is only honest for
    * undefined-armed union types (the interned arm) and checked-dynamic
-   * bindings (the DOM undefined). Everything else returns false
+   * bindings (the dyn undefined). Everything else returns false
    * and the reference lands on the named fence in rejectUnresolvedSymbol:
    * a slot of a narrower type has no bit pattern for the `undefined` Node
    * would yield if the capture ran early, and guessing "it won't" is the

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

@@ -486,7 +486,7 @@ export function hoistVarBinding(L, symbol, nameNode) {
     const local = { id: `${name}.${count}`, name, type, mutable: true };
     L.ctx.locals.push(local);
     L.ctx.scopes[0].set(symbol, local);
-    // A checked-dynamic slot holds the DOM undefined (a NULL dyn is a
+    // A checked-dynamic slot holds the dyn undefined (a NULL dyn is a
     // trap); everything else rides unassignedSlotInit (interned union arm,
     // engine undefined for jsval).
     const wrapped = type.kind === "dyn" ? dynUndefinedExpr(locOf(nameNode)) : L.unassignedSlotInit(type, locOf(nameNode));
@@ -502,7 +502,7 @@ export function hoistVarBinding(L, symbol, nameNode) {
    * such reads `undefined`, never a TDZ error, so the hoisted slot must
    * hold `undefined` from function entry — which is only honest for
    * undefined-armed union types (the interned arm) and checked-dynamic
-   * bindings (the DOM undefined). Everything else returns false
+   * bindings (the dyn undefined). Everything else returns false
    * and the reference lands on the named fence in rejectUnresolvedSymbol:
    * a slot of a narrower type has no bit pattern for the `undefined` Node
    * would yield if the capture ran early, and guessing "it won't" is the
@@ -536,7 +536,7 @@ export function predeclareForwardVar(L, symbol) {
     const ctx = owner.ctx;
     // Only a slot that can hold `undefined` can carry the pre-
     // initialization reads: an undefined-armed union (the interned arm),
-    // a checked-dynamic binding (the DOM undefined), or a jsval 'any'
+    // a checked-dynamic binding (the dyn undefined), or a jsval 'any'
     // binding (the engine's undefined).
     const type = varBindingType(L, nameNode);
     if (!type)
@@ -757,7 +757,7 @@ export function lowerStmt(L, stmt) {
         // A bare `return;` in a union-returning function yields undefined
         // (JS), which the undefined arm carries — tsc only allows the bare
         // form when the return type includes undefined/void. A CHECKED-
-        // DYNAMIC return slot holds the DOM undefined directly (the
+        // DYNAMIC return slot holds the dyn undefined directly (the
         // appendImplicitUndefinedReturn rule). What remains is JS-only —
         // a JSDoc return claim the body contradicts (ms's parse: `@return
         // {Number}` with a bare early `return;`): no undefined fits the
@@ -819,11 +819,11 @@ export function lowerStmt(L, stmt) {
         const value = L.lowerExpr(stmt.expression);
         if (value.type.kind === "void")
             L.badType(stmt.expression, L.typeOf(stmt.expression));
-        // A dyn throw rides the REF cell arm (scr_throw_ref over the DOM
+        // A dyn throw rides the REF cell arm (scr_throw_ref over the checked-dynamic tree
         // node — identity preserved through catch bindings, caughtToDyn
         // passes it back by reference). The JS-lane traced-call shape:
-        // `throw err` where err arrived as a DOM argument. instanceof
-        // narrowing over the payload stays false (the DOM's %error encoding
+        // `throw err` where err arrived as a dyn argument. instanceof
+        // narrowing over the payload stays false (the checked-dynamic tree's %error encoding
         // is not a hierarchy object — SEMANTICS.md).
         return { kind: "throw", value, loc: locOf(stmt) };
     }
@@ -919,9 +919,9 @@ export function lowerVarStatement(L, stmt) {
         }
         // `const { NGHTTP2_CANCEL } = http2.constants` — a destructure over
         // the baked constants table: alias plumbing, no storage (uses read
-        // their literals via http2ConstantBindingOf; collectGlobals skipped
+        // their literals via builtinConstantBindingOf; collectGlobals skipped
         // the globals by the same test).
-        if (L.http2ConstantsDestructureDecl(decl.name, decl.initializer))
+        if (L.builtinConstantsDestructureDecl(decl.name, decl.initializer))
             return [];
         if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
             // `const { createSign } = crypto` over a builtin NAMESPACE binding:
@@ -1018,7 +1018,7 @@ export function lowerDestructuringDecl(L, decl, isLet) {
     let init = L.lowerExpr(decl.initializer);
     // A TS `any`-origin source whose lowered value is NOT a destructurable
     // shape (`var { x } = <any>0` — the cast erases to the f64; a dyn
-    // value — the DOM has no destructure): JS reads the properties off
+    // value — the checked-dynamic tree has no destructure): JS reads the properties off
     // whatever the value is (a number answers undefined) — engine
     // semantics, the dynamic-family fence. Record and array sources fall
     // through to their lowerings, island handles to theirs (--dynamic
@@ -1276,16 +1276,16 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
             L.lowerBindingPattern(pattern, () => ({ kind: "varRef", localId: chars.id, type: charsT, loc }), charsT, isLet, out);
             return;
         }
-        // DYN sources (`const [a, b] = d` over a DOM value, `([_, code]) =>`
+        // DYN sources (`const [a, b] = d` over a dyn value, `([_, code]) =>`
         // params destructuring dyn callback arguments — the suite harness's
         // _expectWarning shapes): the source packs ONCE through the spread
         // walk (dyn.iterPack — arrays element-by-element, strings by code
         // point, bytes by byte; every other kind throws V8's destructuring
         // TypeError, the compile-time spelling when the source has one),
         // then positions bind the pack's index keys as dyn values — reads
-        // past the end bind undefined, exactly JS. Defaults fire on the DOM
+        // past the end bind undefined, exactly JS. Defaults fire on the checked-dynamic tree
         // undefined (JS's rule); rest elements keep the fence (surplus
-        // packing over the DOM needs a slice the IR does not spell yet).
+        // packing over the checked-dynamic tree needs a slice the IR does not spell yet).
         if (srcType.kind === "dyn") {
             const loc = locOf(pattern);
             const pack = L.declareHiddenLocal("%dpack", DYN);
@@ -1316,14 +1316,14 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
                     loc: elLoc,
                 };
                 if (el.initializer) {
-                    // The default fires exactly on the DOM undefined (JS's rule),
-                    // its value converting into the DOM like any dyn-slot value.
+                    // The default fires exactly on the dyn undefined (JS's rule),
+                    // its value converting into the checked-dynamic tree like any dyn-slot value.
                     const rl = L.declareHiddenLocal("%delem", DYN);
                     out.push({ kind: "varDecl", localId: rl.id, init: value, loc: elLoc });
                     const ref = () => ({ kind: "varRef", localId: rl.id, type: DYN, loc: elLoc });
                     const dflt = L.coerceToExpected(L.lowerExpr(el.initializer), DYN);
                     if (dflt.type.kind !== "dyn") {
-                        L.unsupported("SC1031", el.initializer, `defaults of '${L.fmt(dflt.type)}' type over checked-dynamic sources (the value cannot convert into the DOM)`);
+                        L.unsupported("SC1031", el.initializer, `defaults of '${L.fmt(dflt.type)}' type over checked-dynamic sources (the value cannot convert into the checked-dynamic tree)`);
                     }
                     value = {
                         kind: "ternary",
@@ -2537,7 +2537,7 @@ export function bindPatternTarget(L, name, value, isLet, out) {
         // a pattern binding whose VALUE lowered checked-dynamic stays dyn
         // where the checker spells an island-world type (`function f({
         // plugins = [] } = {})` over a JSDoc '(string | object)[]=' member —
-        // the read is a DOM keyed read whose members may be wrapped island
+        // the read is a dyn keyed read whose members may be wrapped island
         // values) or a type with no mapping at all (the varDecl rule's
         // unmappable-declared-type stance, `string | object` bindings
         // included). Marshaling here would fence or deep-copy; the value's
@@ -2702,9 +2702,9 @@ export function lowerVarDecl(L, decl, isLet) {
         return null;
     // `const { NGHTTP2_CANCEL } = http2.constants` — a destructure over
     // the baked constants table: alias plumbing, no storage (uses read
-    // their literals via http2ConstantBindingOf; collectGlobals skipped
+    // their literals via builtinConstantBindingOf; collectGlobals skipped
     // the globals by the same test).
-    if (L.http2ConstantsDestructureDecl(decl.name, decl.initializer))
+    if (L.builtinConstantsDestructureDecl(decl.name, decl.initializer))
         return null;
     // `const Writable = stream.Writable` — a stream class through the
     // namespace binding: alias plumbing, no storage (uses resolve through
@@ -2790,7 +2790,7 @@ export function lowerVarDecl(L, decl, isLet) {
             // a loop — must NOT reset the persisting binding.
             if (isVarDeclared(decl))
                 return null;
-            // Checked-dynamic globals hold the DOM undefined from their
+            // Checked-dynamic globals hold the dyn undefined from their
             // declaration statement on; unions and jsval ride
             // unassignedSlotInit's arms.
             const wrapped = g.type.kind === "dyn" ? dynUndefinedExpr(locOf(decl)) : L.unassignedSlotInit(g.type, locOf(decl));
@@ -2845,7 +2845,7 @@ export function lowerVarDecl(L, decl, isLet) {
         const local = L.declareLocal(decl.name, decl.name.text, type, isLet);
         // tsc's definite-assignment analysis never guards `any` reads, so
         // uninitialized bindings must hold their world's undefined, never
-        // NULL: unions the interned arm, dyn the DOM undefined, jsval the
+        // NULL: unions the interned arm, dyn the dyn undefined, jsval the
         // engine's — all readable immediately, exactly Node.
         const init = type.kind === "dyn" ? dynUndefinedExpr(locOf(decl)) : L.unassignedSlotInit(type, locOf(decl));
         return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
@@ -2869,7 +2869,7 @@ export function lowerVarDecl(L, decl, isLet) {
     }
     // A dyn initializer under an unmappable declared type (`const ws =
     // pkg.workspaces` — the lowering world types the unknown-receiver read
-    // `any`, which a static build cannot hold): the VALUE is a DOM
+    // `any`, which a static build cannot hold): the VALUE is a dyn
     // subtree, so the local stays dyn — later narrowing tests and checked
     // casts read it like any JSON.parse result.
     // `const p = import("./m")` / `const ns = await import("./m")`: the
@@ -2894,7 +2894,7 @@ export function lowerVarDecl(L, decl, isLet) {
         // the island-HANDLE local rule's mirror): a binding whose
         // INITIALIZER lowered checked-dynamic stays dyn even where the
         // checker spells 'any' (`const parsers = options.parsers ?? {}` over
-        // an 'object'-typed bag — the read is a DOM keyed read). Marshaling
+        // an 'object'-typed bag — the read is a dyn keyed read). Marshaling
         // into the engine here would deep-copy data and sever aliasing; the
         // value's world is the honest dispatch, and every use site already
         // handles dyn (validated exits, routed engine ops for wrapped
@@ -2921,7 +2921,7 @@ export function lowerVarDecl(L, decl, isLet) {
     // pushes of anything non-numeric would fence and typed exits would
     // mismatch the checker's evolved reads downstream. The binding is
     // checked-dynamic instead (the `let x = {}` stance, and lower-modules'
-    // file-scope evolving-array rule): pushes ride the DOM array, typed
+    // file-scope evolving-array rule): pushes ride the dyn array, typed
     // exits dynCheck.
     if ((type === null || type.kind === "array") && isJsSourceFile(decl.getSourceFile())) {
         let initExpr = decl.initializer;
@@ -3000,6 +3000,15 @@ export function lowerVarDecl(L, decl, isLet) {
     // bridge is an independent observer of the same settlement).
     if (init.type.kind === "jsval" && type.kind === "promise")
         type = JSVAL;
+    // An island value under an `any[]`-declared LOCAL spelling stays an
+    // island HANDLE too (the runtime-world rule): the jsval-element-array
+    // exit is a CALL-boundary conversion (the loadPlugins param ABI) —
+    // converting a local would strand the engine's own prototypes
+    // (join/map/... on a native handle-element array), where the handle
+    // routes every use engine-side.
+    if (init.type.kind === "jsval" && type.kind === "array" && type.elem.kind === "jsval") {
+        type = JSVAL;
+    }
     // A STATIC array of island HANDLES under an unannotated declared type
     // spelling evolved elements (`const kept = fns.filter(...)` over an
     // evolving-`any` receiver — the handle-element lowering keeps the
@@ -3847,7 +3856,7 @@ export function lowerExprStatement(L, expr) {
                     const loc = locOf(expr);
                     // Dispatch follows the RUNTIME world (383(d)): a checker-'any'
                     // receiver whose value LOWERED checked-dynamic (`bag.nested.x
-                    // = v` behind an 'object'-typed bag) takes the DOM keyed
+                    // = v` behind an 'object'-typed bag) takes the dyn keyed
                     // write — the routed JSVAL arm lands it on the real engine
                     // object.
                     if (obj.type.kind === "dyn") {
@@ -3944,7 +3953,7 @@ export function lowerExprStatement(L, expr) {
                 }
                 // `h.onDone = cb` on a CHECKED-DYNAMIC receiver (a JS `let h =
                 // {}` evolving object, an implicit-any param, a dyn member
-                // chain): the DOM keyed write — the value converts INTO dyn
+                // chain): the dyn keyed write — the value converts INTO dyn
                 // (closures box), the runtime sets the member on OBJ receivers
                 // and throws Node's TypeErrors on the rest. The receiver is
                 // PROBED (probeLower) and claimed exactly when it lowers to
@@ -3964,7 +3973,7 @@ export function lowerExprStatement(L, expr) {
                 }
                 // `events.defaultMaxListeners = v` in STATEMENT position — the
                 // module-property write Node validates (the lowerBinary
-                // expression twin): the value crosses into the DOM, the runtime
+                // expression twin): the value crosses into the checked-dynamic tree, the runtime
                 // ladder throws Node's exact errors, valid numbers apply.
                 if (!expr.left.questionDotToken && expr.left.name.text === "defaultMaxListeners") {
                     const bi = L.builtinMemberOf(expr.left);
@@ -4268,7 +4277,7 @@ function lowerCompoundToTarget(L, expr, compound, target) {
         isJsSourceFile(expr.getSourceFile())) {
         // JS any-origin operands: check to number and compute natively
         // (the binary-operator stance) — the dyn target takes the result
-        // back through the usual DOM conversion.
+        // back through the usual dyn conversion.
         const checkNum = (e) => e.type.kind === "dyn" ? { kind: "dynCheck", value: e, type: F64, loc: e.loc } : e;
         const computed = { kind: "bin", op: compound, left: checkNum(read), right: checkNum(rhs), type: F64, loc };
         value = target.type.kind === "dyn" ? { kind: "dynFrom", value: computed, type: DYN, loc } : computed;
@@ -5100,7 +5109,7 @@ function destructAssignPiece(L, prop, islandSource) {
         // keys resolve statically (the record path's rule) — the keyed read
         // below takes the folded name. A RUNTIME-valued key over an ISLAND
         // source reads through the engine's own indexing at the element's
-        // pattern position (`({ [key]: w } = src)`); over the DOM the fence
+        // pattern position (`({ [key]: w } = src)`); over the checked-dynamic tree the fence
         // stays.
         const folded = patternKeyNameOf(L, prop.name);
         if (folded === null) {
@@ -5550,12 +5559,12 @@ export function lowerForOf(L, stmt) {
         if (iterable.type.kind === "jsval") {
             return lowerForOfIsland(L, stmt, iterable, labels);
         }
-        // A CHECKED-DYNAMIC iterable (`unknown[]` and the collapsed
-        // `(string | object)[]` are DOM values now, so the TYPE maps —
-        // badType would tell a stale component story): the OPERATION is
-        // the gap — name it, with the validated-cast escape hatch.
+        // A CHECKED-DYNAMIC iterable (`unknown[]`, the collapsed
+        // `(string | object)[]`, JSON-parsed values, wrapped engine
+        // values): the source packs ONCE through the spread walk and a
+        // hidden index loop binds each element as a dyn value.
         if (iterable.type.kind === "dyn") {
-            L.unsupported("SC1090", stmt.expression, "for-of over checked-dynamic ('unknown') values (validate into a typed array first — `u as string[]` — or index with a counted loop: length and element reads compile)");
+            return lowerForOfDyn(L, stmt, iterable, labels);
         }
         if (iterable.type.kind !== "array") {
             L.badType(stmt.expression, L.typeOf(stmt.expression));
@@ -5928,6 +5937,158 @@ function lowerForOfClassIterator(L, stmt, iterable, cit, labels) {
  * (break/return out of a partial iteration calling it.return()) is NOT
  * run — a divergence only a custom island iterator with a return()
  * method can observe. */
+/** For-of over a CHECKED-DYNAMIC iterable: the source packs ONCE
+ * through the spread walk (dyn.iterPack — dyn arrays element-by-
+ * element, strings by code point, bytes by byte; a WRAPPED engine
+ * value drains through the ENGINE's own iterator protocol via the
+ * iter_drain arm; every other kind throws V8's not-iterable
+ * TypeError, the identifier spelling when the head has one), then a
+ * hidden index loop binds each element as a dyn value. The pack is an
+ * eager SNAPSHOT (the matchAll stance): body mutations of a dyn-array
+ * source don't extend the iteration where JS's live array iterator
+ * would — documented divergence; engine sources drain through their
+ * own protocol, so generators/Maps/Sets step exactly once like Node. */
+function lowerForOfDyn(L, stmt, iterable, labels) {
+    const loc = locOf(stmt);
+    const head = stmt.expression;
+    // V8's for-of CallPrinter spellings: named sources (identifiers and
+    // plain property chains) read "<src> is not iterable", call heads
+    // with a nameable callee "<callee> is not a function or its return
+    // value is not iterable"; everything else keeps the runtime kind
+    // wording. The runtime uses the spelling VERBATIM when non-empty.
+    const headText = (e) => {
+        if (ts.isIdentifier(e))
+            return e.text;
+        if (ts.isPropertyAccessExpression(e) && !e.questionDotToken && ts.isIdentifier(e.name)) {
+            const base = headText(e.expression);
+            return base !== null ? `${base}.${e.name.text}` : null;
+        }
+        return null;
+    };
+    const headName = headText(head);
+    const calleeName = ts.isCallExpression(head) ? headText(head.expression) : null;
+    const spell = headName !== null
+        ? `${headName} is not iterable`
+        : calleeName !== null
+            ? `${calleeName} is not a function or its return value is not iterable`
+            : "";
+    const pack = L.declareHiddenLocal("%dofpack", DYN);
+    const idx = L.declareHiddenLocal("%dofi", F64);
+    idx.mutable = true;
+    const packRef = () => ({ kind: "varRef", localId: pack.id, type: DYN, loc });
+    const iRef = () => ({ kind: "varRef", localId: idx.id, type: F64, loc });
+    const elemInit = () => ({ kind: "libCall", fn: "dyn.arrAt", args: [packRef(), iRef()], type: DYN, loc });
+    L.scopes.push(new Map());
+    try {
+        const binds = [];
+        if (!ts.isVariableDeclarationList(stmt.initializer)) {
+            // Pre-declared heads: identifier targets assign the existing
+            // binding once per pass (JS's shared-binding rule); literal
+            // patterns run the destructuring-assignment machinery over the
+            // dyn element; member targets keep the fence.
+            let target = stmt.initializer;
+            while (ts.isParenthesizedExpression(target))
+                target = target.expression;
+            const tmp = L.declareHiddenLocal("%vof", DYN);
+            binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit(), loc });
+            const elemRef = { kind: "varRef", localId: tmp.id, type: DYN, loc };
+            if (ts.isArrayLiteralExpression(target) || ts.isObjectLiteralExpression(target)) {
+                binds.push(lowerDestructuringAssign(L, target, elemRef, target, loc));
+            }
+            else if (ts.isIdentifier(target) && L.resolveWritable(target)) {
+                const writable = L.resolveWritable(target);
+                binds.push({
+                    kind: "assign",
+                    localId: writable.id,
+                    value: L.coerceInto(target, elemRef, writable.type),
+                    loc,
+                });
+            }
+            else {
+                L.unsupported("SC1090", stmt.initializer, "for-of over a pre-declared variable (declare the loop variable in the loop: for (const x of ...))");
+            }
+        }
+        else {
+            const list = stmt.initializer;
+            if ((list.flags & ts.NodeFlags.Using) !== 0) {
+                L.unsupported("SC1090", list, "'using' declarations (dispose-at-scope-exit semantics)");
+            }
+            const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
+            const decl = list.declarations[0];
+            if (ts.isArrayBindingPattern(decl.name) || ts.isObjectBindingPattern(decl.name)) {
+                const tmp = L.declareHiddenLocal("%destr", DYN);
+                binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit(), loc });
+                L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: DYN, loc }), DYN, isLet, binds);
+            }
+            else if (ts.isIdentifier(decl.name)) {
+                const varTarget = forOfVarTarget(L, decl);
+                if (varTarget) {
+                    // `for (var x of d)`: the element mechanics stay on a hidden
+                    // per-iteration local; the body opens by assigning the ONE
+                    // hoisted var binding (the array head's rule).
+                    const tmp = L.declareHiddenLocal("%vof", DYN);
+                    binds.push({ kind: "varDecl", localId: tmp.id, init: elemInit(), loc });
+                    binds.push({
+                        kind: "assign",
+                        localId: varTarget.id,
+                        value: L.coerceInto(decl.name, { kind: "varRef", localId: tmp.id, type: DYN, loc }, varTarget.type),
+                        loc,
+                    });
+                }
+                else {
+                    const local = L.declareLocal(decl.name, decl.name.text, DYN, isLet);
+                    binds.push({ kind: "varDecl", localId: local.id, init: elemInit(), loc });
+                }
+            }
+            else {
+                L.unsupported("SC1031", decl.name);
+            }
+        }
+        const body = L.inCtl("loop", () => L.lowerScopedBlock(stmt.statement), labels);
+        return {
+            kind: "block",
+            body: [
+                {
+                    kind: "varDecl",
+                    localId: pack.id,
+                    init: {
+                        kind: "libCall",
+                        fn: "dyn.iterPack",
+                        args: [iterable, { kind: "strLit", value: spell, type: STRING, loc }],
+                        type: DYN,
+                        loc,
+                    },
+                    loc,
+                },
+                {
+                    kind: "for",
+                    init: { kind: "varDecl", localId: idx.id, init: { kind: "numLit", value: 0, type: F64, loc }, loc },
+                    cond: {
+                        kind: "bin",
+                        op: "<",
+                        left: iRef(),
+                        right: { kind: "libCall", fn: "dyn.arrLen", args: [packRef()], type: F64, loc },
+                        type: BOOL,
+                        loc,
+                    },
+                    update: {
+                        kind: "assign",
+                        localId: idx.id,
+                        value: { kind: "bin", op: "+", left: iRef(), right: { kind: "numLit", value: 1, type: F64, loc }, type: F64, loc },
+                        loc,
+                    },
+                    body: [...binds, ...body],
+                    ...(labels && { labels }),
+                    loc,
+                },
+            ],
+            loc,
+        };
+    }
+    finally {
+        L.scopes.pop();
+    }
+}
 function lowerForOfIsland(L, stmt, iterable, labels) {
     const loc = locOf(stmt);
     if (!ts.isVariableDeclarationList(stmt.initializer)) {