@scriptc/compiler 0.3.2 → 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.
@@ -805,7 +808,7 @@ function varBindingType(lowerer, nameNode) {
  * 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
@@ -871,8 +874,8 @@ 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))
@@ -2119,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)
@@ -3036,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. */
@@ -3051,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)");
         }
     }
@@ -4080,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")
@@ -4873,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;
@@ -5214,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
@@ -5232,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);
@@ -5293,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)) {
@@ -5447,6 +5459,20 @@ export function lowerExprStatement(lowerer, expr) {
                             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
@@ -6677,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) {
         {
@@ -8341,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)");
             }