@scriptc/compiler 0.3.1 → 0.3.3

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

@@ -1,4 +1,5 @@
 import { dynUndefinedExpr, numLit, varRef } from "../../ir/build.js";
+import { lowerEventObjectPropertyWrite } from "./lower-event-target.js";
 import { lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { importMetaBindingSource } from "./import-meta.js";
 import { iteratorCanStep, iteratorValue } from "./iterator-consumption.js";
@@ -40,6 +41,7 @@ import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment, } from "./lower-server.js";
 import { lowerUrlAssignment } from "./builtins/url.js";
+import { isFspGlobCall, lowerFspGlobForAwait } from "./builtins/fs-glob.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, } from "./builtins/module-bindings.js";
 import { lowerNodeModuleCall } from "./builtins/module-resolution.js";
 import { registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
@@ -59,6 +61,7 @@ import { probeNodeRequireRefusal } from "../npm.js";
 import { constituentTypes } from "../ts7/checker.js";
 import { npmStaticPackageOfPath } from "../npm-static.js";
 import { fenceNodeModuleMutation } from "./lower-node-module.js";
+import { fencePerfEntryKeyWalk } from "./builtins/performance.js";
 /** An opted package's directly-returned empty array may take the function's
  * explicit static return element type. This is the common JS accumulator
  * shape (`const result = []; result.push(value); return result`) and is
@@ -524,7 +527,7 @@ export function lowerStmts(lowerer, stmts) {
                 // only — a capture wrapper in force means collection owns the
                 // report). The statement's diagnostics move OFF the build and
                 // onto the fence: executing the statement throws the first
-                // one's message, so nothing is ever silently dropped — either
+                // one's message, so no diagnostic is dropped — either
                 // the statement never runs (Node parity: the construct never
                 // executed) or it reports exactly what the compile fence would
                 // have said.
@@ -798,13 +801,14 @@ function varBindingType(lowerer, nameNode) {
     }
     if (!type || type.kind === "void")
         return null;
-    return type;
+    // A binding readable before its first store holds undefined until then.
+    return lowerer.runtimeOptionalBindingType(nameNode, type);
 }
 /** `var` declarations hoist to their FUNCTION: the binding exists across
  * the whole enclosing function body regardless of block position, and
  * every same-name `var` in that function is the SAME binding (tsc merges
  * the declarations into one symbol, so symbol-keyed resolution gets the
- * merge for free). This mints the one function-scoped slot on first
+ * merge automatically). This mints the one function-scoped slot on first
  * encounter: an IrLocal registered in the function's ROOT scope frame
  * (never popped by block exits) whose `varDecl` is PUSHED into the
  * function-root statement list at the current position — everything
@@ -849,6 +853,7 @@ function hoistVarBinding(lowerer, symbol, nameNode) {
     };
     lowerer.ctx.locals.push(local);
     lowerer.ctx.scopes[0].set(symbol, local);
+    noteEarlyReadVar(lowerer, symbol, local);
     // A checked-dynamic slot holds the dyn undefined (a NULL dyn is a
     // trap); everything else rides unassignedSlotInit (interned union arm,
     const wrapped = type.kind === "dyn"
@@ -869,9 +874,12 @@ function hoistVarBinding(lowerer, symbol, nameNode) {
  * 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
- * silent-wrong-output sin. */
+ * would yield if the capture ran early, and guessing "it won't" would
+ * produce wrong output without an error. */
 export function predeclareForwardVar(lowerer, symbol) {
+    // Module-scope vars already have their global storage.
+    if (lowerer.globalsBySymbol.has(symbol))
+        return false;
     const decl = lowerer.checker.valueDeclarationOf(symbol);
     if (!decl || !ts.isVariableDeclaration(decl) || !isVarDeclared(decl))
         return false;
@@ -921,10 +929,20 @@ export function predeclareForwardVar(lowerer, symbol) {
     };
     ctx.locals.push(local);
     ctx.scopes[0].set(symbol, local);
+    noteEarlyReadVar(lowerer, symbol, local);
     root.out.push({ kind: "varDecl", localId: local.id, init: wrapped, loc: locOf(decl) });
     ctx.hoistedVars.set(symbol, local);
     return true;
 }
+/** A var readable before its first store (the runtime-optional analysis
+ * widened it): reads keep the undefined-armed value. */
+function noteEarlyReadVar(lowerer, symbol, local) {
+    if (!lowerer.earlyReadVars.has(symbol))
+        return;
+    const root = lowerer.runtimeOptionalRootOf(local);
+    lowerer.runtimeOptionalLocals.add(root);
+    lowerer.runtimeOptionalStorageLocals.add(root);
+}
 /** Records the symbols a poisoned DECLARATION statement would have bound
  * (identifier and pattern names alike, for-initializers included) so
  * later references report the SC2004 cascade. Registered bindings win:
@@ -1131,6 +1149,9 @@ export function lowerStmt(lowerer, stmt) {
         else if (lowerer.ctx.returnType.kind !== "void") {
             lowerer.unsupported("SC1090", stmt, `bare 'return' where the declared return type is '${lowerer.fmt(lowerer.ctx.returnType)}' (JS hands the caller undefined, which this representation cannot hold — return a value, or widen the declared return type with undefined)`);
         }
+        // An async generator's bare return has no operand to await.
+        if (lowerer.ctx.isAsync === true && lowerer.ctx.generator)
+            return { kind: "return", value, awaited: true, loc: locOf(stmt) };
         return { kind: "return", value, loc: locOf(stmt) };
     }
     if (ts.isBreakStatement(stmt) || ts.isContinueStatement(stmt)) {
@@ -2101,7 +2122,7 @@ export function lowerBindingPattern(lowerer, pattern, srcRef, srcType, isLet, ou
     // reads (base-chain accessors and setter-only rejections resolve
     // identically). Rest elements, methods, and names no class on the
     // chain declares keep named fences (a detached method would lose its
-    // receiver silently; JS binds the prototype function).
+    // receiver without an error; JS binds the prototype function).
     if (srcType.kind === "object") {
         const info = lowerer.classes.get(srcType.className);
         if (!info)
@@ -3018,12 +3039,12 @@ function objectRestValue(lowerer, el, srcRef, srcType, shape) {
  * members (methods and accessors stay behind; the checker's rest type
  * excludes them too, so the two sides agree). The packed record must
  * agree with the checker's rest type field-for-field — a non-public
- * field IS copied by JS but the rest type cannot name it (silent
+ * field IS copied by JS but the rest type cannot name it (undiagnosed
  * divergence; fence) — and key-for-key in ORDER: the packed shape's
  * JSON/Object.keys order is first-seen global metadata, and a checker
  * rest type that reorders (own-before-inherited) would make the
  * enumeration surfaces diverge from Node, so it fences instead of
- * silently reordering. Runtime-provided chains (Error/EventEmitter/
+ * reordering. Runtime-provided chains (Error/EventEmitter/
  * stream roots) carry runtime-internal state no record copy can
  * reproduce — fenced. ES-#private fields are own but non-enumerable:
  * JS skips them and so does the packing. */
@@ -3033,7 +3054,7 @@ function classInstanceRestValue(lowerer, blame, srcRef, srcType, info, consumed,
         lowerer.unsupported("SC1031", blame, "rest bindings over class instances with symbol-keyed fields (the copied symbols have no record form)");
     }
     for (let c = info; c; c = c.base) {
-        if (c.builtinError || c.builtinEmitter || c.builtinStream) {
+        if (c.builtinError || c.builtinEmitter || c.builtinStream || c.builtinEventTarget) {
             lowerer.unsupported("SC1031", blame, "rest bindings over runtime-provided class instances (Error/EventEmitter/stream internals have no record form)");
         }
     }
@@ -4062,6 +4083,9 @@ function annotatedInitializerTarget(lowerer, name) {
 function inferredOptionalRecordType(lowerer, decl, declared, actual) {
     if (decl.type || hasJsTypeAnnotation(decl))
         return declared;
+    const symbol = ts.isIdentifier(decl.name) ? lowerer.resolveValueSymbol(decl.name) : undefined;
+    if (symbol && lowerer.runtimeOptionalRecordsKeptDeclared.has(symbol))
+        return declared;
     if (lowerer.isRuntimeOptionalRecordVariant(actual, declared))
         return actual;
     if (declared.kind !== "record" || actual.kind !== "record")
@@ -4855,7 +4879,7 @@ function lowerCjsExportStatement(lowerer, cjs) {
     // through to the declaration) — EXACT for const/function bindings, a
     // live-binding lie for `let`: Node copies the VALUE into the table at
     // this statement, so later reassignments are invisible to importers.
-    // Mutable bindings fence instead of diverging silently.
+    // Mutable bindings fence instead of diverging from Node.
     const fenceMutable = (nameNode) => {
         const sym = lowerer.resolveValueSymbol(nameNode);
         const g = sym ? lowerer.globalsBySymbol.get(sym) : undefined;
@@ -5196,6 +5220,12 @@ export function lowerExprStatement(lowerer, expr) {
                 return lowerer.lowerElementWrite(expr);
             if (ts.isPropertyAccessExpression(expr.left)) {
                 fenceNodeModuleMutation(lowerer, expr.left, "assignment");
+                // The writable Event accessors on Event subclass instances.
+                {
+                    const eventWrite = lowerEventObjectPropertyWrite(lowerer, expr.left, expr.right);
+                    if (eventWrite)
+                        return { kind: "exprStmt", expr: eventWrite, loc: locOf(expr) };
+                }
                 // Native arrays have a writable length property. The runtime grows
                 // by creating holes and truncates with RC-aware removal; keep this
                 // as a statement operation so invalid lengths can use the normal
@@ -5214,7 +5244,7 @@ export function lowerExprStatement(lowerer, expr) {
                 // `process.env.NAME = v` — setenv(3): later env reads and spawned
                 // children observe the write, exactly Node. Values are strings
                 // (Node stringifies everything; a non-string RHS fences instead
-                // of silently diverging). The computed-key form lands in
+                // of diverging from Node). The computed-key form lands in
                 // lowerElementWrite.
                 if (lowerer.isProcessEnv(expr.left.expression) && !expr.left.questionDotToken) {
                     const loc = locOf(expr);
@@ -5275,7 +5305,7 @@ export function lowerExprStatement(lowerer, expr) {
                 // own name: the field's module global assigns. Writes through a
                 // SUBCLASS name (`D.x = v` creates an OWN property on D in JS —
                 // different storage) and through class VALUES (the same dynamic
-                // story) are named fences, never a silently-wrong global write.
+                // story) are named fences instead of an incorrect global write.
                 if (!expr.left.questionDotToken &&
                     (ts.isIdentifier(expr.left.expression) ||
                         expr.left.expression.kind === ts.SyntaxKind.ThisKeyword)) {
@@ -5412,6 +5442,38 @@ export function lowerExprStatement(lowerer, expr) {
                         loc,
                     };
                 }
+                if (!expr.left.questionDotToken) {
+                    const flag = lowerer.stdlibGlobalMember(expr.left, "process");
+                    if (flag === "noDeprecation" || flag === "throwDeprecation") {
+                        const loc = locOf(expr);
+                        const value = lowerer.lowerExprExpecting(expr.right, DYN);
+                        return {
+                            kind: "exprStmt",
+                            expr: {
+                                kind: "libCall",
+                                fn: "process.setDeprecationFlag",
+                                args: [numLit(flag === "noDeprecation" ? 0 : 1, loc), value],
+                                type: VOID,
+                                loc,
+                            },
+                            loc,
+                        };
+                    }
+                    // process.title = name: libuv's uv_set_process_title (the
+                    // runtime truncates to the original argument area on POSIX).
+                    if (flag === "title") {
+                        const loc = locOf(expr);
+                        const value = lowerer.lowerExpr(expr.right);
+                        if (value.type.kind !== "string") {
+                            lowerer.noLowering(`process.title writes of '${lowerer.fmt(value.type)}' values`, expr.right, "assign a string");
+                        }
+                        return {
+                            kind: "exprStmt",
+                            expr: { kind: "libCall", fn: "process.setTitle", args: [value], type: VOID, loc },
+                            loc,
+                        };
+                    }
+                }
                 // `r._read = fn` / `w._write = fn` (and the other underscore
                 // methods) on a runtime-stream-rooted receiver: Node's
                 // own-property shadow of the prototype method — the runtime
@@ -6641,6 +6703,13 @@ export function lowerForOf(lowerer, stmt) {
     // A synchronous array iterator is also valid in `for await`. Its values
     // take the async-from-sync path below; other async sources retain their
     // dedicated request protocols.
+    if (stmt.awaitModifier) {
+        let head = stmt.expression;
+        while (ts.isParenthesizedExpression(head))
+            head = head.expression;
+        if (isFspGlobCall(lowerer, head))
+            return lowerFspGlobForAwait(lowerer, stmt, head);
+    }
     const awaitArray = !!stmt.awaitModifier && lowerer.mapTypeOf(lowerer.typeOf(stmt.expression))?.kind === "array";
     if (stmt.awaitModifier && !awaitArray) {
         {
@@ -6835,7 +6904,7 @@ export function lowerForOf(lowerer, stmt) {
         if (iterable.type.kind === "string") {
             // JS's string iterator walks code POINTS, not units: each pass
             // yields the whole character (two UTF-16 units for astral chars,
-            // where charAt would truncate to U+FFFD).
+            // where charAt returns one surrogate half).
             return lowerForOfString(lowerer, stmt, iterable, labels);
         }
         if (iterable.type.kind === "map") {
@@ -7659,8 +7728,8 @@ function lowerForOfMatchAll(lowerer, stmt, call, stored) {
 }
 /** `for (const ch of s)` over a STRING: JS's string iterator, which walks
  * code POINTS — each pass binds the whole character (a two-unit string
- * for astral chars, where charAt/slice would truncate the halves to
- * U+FFFD). Desugars over the UTF-16 cursor machinery: a hidden unit
+ * for astral chars, where charAt/slice would return one surrogate half).
+ * Desugars over the UTF-16 cursor machinery: a hidden unit
  * index reads the character with the cpAt intrinsic and advances by ITS
  * length before the body runs (so `continue` never skips the advance):
  *
@@ -7668,9 +7737,8 @@ function lowerForOfMatchAll(lowerer, stmt, call, stored) {
  *     while (%i < %s.length) { const ch = cpAt(%s, %i); %i += ch.length; <body> } }
  *
  * Strings are immutable, so the length is stable and there is no
- * iterator state to unwind on throw; lone surrogates cannot occur in
- * storage (canonicalized to U+FFFD at creation — the documented
- * divergence), so every step lands on a character start. */
+ * iterator state to unwind on throw; a lone surrogate is a one-unit
+ * character, so every step lands on a character start. */
 /** for-of over a CLASS ITERABLE (classIteratorOf's shape) — the
  * iterator protocol as ordinary method calls:
  *
@@ -8261,15 +8329,35 @@ function lowerForIn(lowerer, stmt) {
         const recv = lowerer.declareHiddenLocal("%indyn", DYN);
         const ref = { kind: "varRef", localId: recv.id, type: DYN, loc };
         const keys = {
-            kind: "dynCheck",
-            value: { kind: "libCall", fn: "dyn.forInKeys", args: [ref], type: DYN, loc },
+            kind: "libCall",
+            fn: "dyn.forInKeyStrings",
+            args: [ref],
             type: arrayOf(STRING),
             loc,
         };
-        const loop = lowerForInOverKeys(lowerer, stmt, keys, labels, (key) => classForInHasKey(lowerer, ref, key, loc));
+        // A stable snapshot (a typed record's fields) needs no live presence
+        // test per visit.
+        const stable = lowerer.declareHiddenLocal("%instable", BOOL);
+        const loop = lowerForInOverKeys(lowerer, stmt, keys, labels, (key) => ({
+            kind: "ternary",
+            cond: { kind: "varRef", localId: stable.id, type: BOOL, loc },
+            then: { kind: "boolLit", value: true, type: BOOL, loc },
+            else_: classForInHasKey(lowerer, ref, key, loc),
+            type: BOOL,
+            loc,
+        }));
         return {
             kind: "block",
-            body: [{ kind: "varDecl", localId: recv.id, init: receiver, loc }, loop],
+            body: [
+                { kind: "varDecl", localId: recv.id, init: receiver, loc },
+                {
+                    kind: "varDecl",
+                    localId: stable.id,
+                    init: { kind: "libCall", fn: "dyn.forInStable", args: [ref], type: BOOL, loc },
+                    loc,
+                },
+                loop,
+            ],
             loc,
         };
     }
@@ -8286,7 +8374,8 @@ function lowerForIn(lowerer, stmt) {
             // Accessor-carrying shapes: Node's for-in visits the accessor
             // NAMES (own enumerable properties) — the static key walk omits
             // them (accessor slots live outside declaredOrder), so the loop
-            // fences rather than silently skip keys.
+            // fences rather than skip keys.
+            fencePerfEntryKeyWalk(lowerer, receiver.type, stmt.expression, "for-in");
             if (shapeHasAccessorSlots(rShape)) {
                 lowerer.unsupported("SC1090", stmt.expression, "for-in over a shape carrying get/set accessor properties (Node visits the accessor names — the static key walk cannot; read the properties explicitly)");
             }