@scriptc/compiler 0.3.1 → 0.3.3

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

@@ -3,10 +3,12 @@ import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { unsignedHex } from "../../format-integer.js";
 import { isJsSourceFile } from "../program.js";
-import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, UNDEFINED_T, canConvertToDyn, canDynCheckTo, recordTextCodecClass, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
+import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, isDirentShape, isDynTypedRefType, recordTextCodecClass, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { symbolFieldDisplayName } from "./symbol-fields.js";
+import { eventTargetRootOf } from "./lower-event-target.js";
 import { lowerSystemErrorMap } from "./lower-system-errors.js";
+import { isPerfEntryType, perfEntryJson } from "./builtins/performance.js";
 /* ── IR construction shorthand ───────────────────────────────────────── */
 function concatAll(parts, loc) {
     if (parts.length === 0)
@@ -20,7 +22,7 @@ function concatAll(parts, loc) {
 /* ── property-name rendering (compile-time keys) ─────────────────────── */
 /** strEscape's quote ladder over a COMPILE-TIME string (record field
  * names, format-string chunks never pass through here — only keys).
- * Mirrors scr_inspect.c's insp_quote_into byte-for-byte. */
+ * Mirrors scr_inspect.c's insp_quote_into exactly. */
 function inspectQuote(s) {
     const hasSingle = s.includes("'");
     const quote = !hasSingle
@@ -185,13 +187,35 @@ function inspectSupport(lowerer, t, visiting, out) {
             const info = lowerer.classes.get(t.className);
             if (!info)
                 return `class '${t.className}' has no inspect lowering`;
+            // EventTarget and Event subclasses render through Node's inspectors
+            // for those classes (the runtime's capsule view).
+            if (eventTargetRootOf(info) !== null)
+                return null;
             if (isErrorClass(lowerer, t.className)) {
                 return errorRenderable(info)
                     ? null
                     : "error subclasses with declared fields have no inspect lowering yet (the extra own properties are runtime-dynamic)";
             }
+            // A class with subclasses renders through its checked-dynamic view,
+            // which names the instance's own class and holds its own fields.
             if (info.subclasses.length > 0) {
-                return `inspect of '${t.className}' values is not lowered (the class has subclasses — the runtime value's constructor name and fields are dynamic)`;
+                if (!isDynTypedRefType(t) || visiting.has(t.className))
+                    return null;
+                visiting.add(t.className);
+                const hierarchy = (current) => [
+                    current,
+                    ...current.subclasses.flatMap(hierarchy),
+                ];
+                for (const member of hierarchy(info))
+                    for (const f of member.def.fields) {
+                        if (f.name.startsWith("#") || f.name.startsWith("%"))
+                            continue;
+                        const why = inspectSupport(lowerer, f.type, visiting, out);
+                        if (why !== null)
+                            return why;
+                    }
+                visiting.delete(t.className);
+                return null;
             }
             if (visiting.has(t.className)) {
                 out.recursive = true;
@@ -241,6 +265,20 @@ function isNumberFlag(lowerer, t, v, loc) {
  * with the depth budget `depth` — a direct scalar libCall or a call of
  * the interned per-type helper. */
 export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
+    // A Dirent row renders through its dyn view: Node's `Dirent { ... }`
+    // with the Symbol(type) key.
+    if (t.kind === "record") {
+        const shape = lowerer.shapes.get(t.shapeId);
+        if (shape && isDirentShape(shape)) {
+            return {
+                kind: "libCall",
+                fn: "insp.dyn",
+                args: [lowerer.coerceToExpected(value, DYN), recurse, depth],
+                type: STRING,
+                loc,
+            };
+        }
+    }
     switch (t.kind) {
         case "f64":
             return { kind: "libCall", fn: "insp.f64", args: [value], type: STRING, loc };
@@ -265,6 +303,15 @@ export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
         case "dyn":
             return { kind: "libCall", fn: "insp.dyn", args: [value, recurse, depth], type: STRING, loc };
         case "object":
+            if (eventTargetRootOf(lowerer.classes.get(t.className)) !== null) {
+                return {
+                    kind: "libCall",
+                    fn: "insp.dyn",
+                    args: [lowerer.coerceToExpected(value, DYN), recurse, depth],
+                    type: STRING,
+                    loc,
+                };
+            }
             if (isErrorClass(lowerer, t.className)) {
                 return {
                     kind: "libCall",
@@ -274,6 +321,15 @@ export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
                     loc,
                 };
             }
+            if (lowerer.classes.get(t.className)?.subclasses.length) {
+                return {
+                    kind: "libCall",
+                    fn: "insp.dyn",
+                    args: [lowerer.coerceToExpected(value, DYN), recurse, depth],
+                    type: STRING,
+                    loc,
+                };
+            }
             return {
                 kind: "call",
                 callee: inspectHelper(lowerer, t, loc),
@@ -599,6 +655,66 @@ function inspectHelper(lowerer, t, loc) {
                 type,
                 loc,
             });
+            if (isPerfEntryType(lowerer, t)) {
+                // PerformanceEntry's custom inspect: `[PerformanceMark]` past the
+                // depth budget, otherwise the class name and a nested inspect of
+                // toJSON() one level shallower, in its own context.
+                const className = {
+                    kind: "ternary",
+                    cond: {
+                        kind: "strEq",
+                        negated: false,
+                        left: get("entryType", STRING),
+                        right: strLit("mark", loc),
+                        type: BOOL,
+                        loc,
+                    },
+                    then: strLit("PerformanceMark", loc),
+                    else_: strLit("PerformanceMeasure", loc),
+                    type: STRING,
+                    loc,
+                };
+                const json = perfEntryJson(lowerer, v(), t, loc);
+                const dLess1 = {
+                    kind: "bin",
+                    op: "-",
+                    left: d(),
+                    right: numLit(1, loc),
+                    type: F64,
+                    loc,
+                };
+                locals.push({ id: "in.0", name: "inner", type: STRING, mutable: false });
+                body = [
+                    {
+                        kind: "if",
+                        cond: { kind: "bin", op: ">", left: r(), right: d(), type: BOOL, loc },
+                        then: [ret(concatAll([strLit("[", loc), className, strLit("]", loc)], loc))],
+                        else_: null,
+                        loc,
+                    },
+                    exprStmt({
+                        kind: "libCall",
+                        fn: "insp.nestedBegin",
+                        args: [],
+                        type: { kind: "void" },
+                        loc,
+                    }),
+                    {
+                        kind: "varDecl",
+                        localId: "in.0",
+                        init: inspectExpr(lowerer, json.type, json, numLit(0, loc), dLess1, loc),
+                        loc,
+                    },
+                    ret({
+                        kind: "libCall",
+                        fn: "insp.nestedEnd",
+                        args: [className, varRef("in.0", STRING, loc)],
+                        type: STRING,
+                        loc,
+                    }),
+                ];
+                break;
+            }
             if (shape.tuple) {
                 // Tuples ARE arrays to Node: bracket form, array-extras grouping.
                 if (shape.fields.length === 0) {
@@ -910,13 +1026,13 @@ function inspectHelper(lowerer, t, loc) {
             // Node prints the class's OWN name — the declaration's, never the
             // IR name's module qualifier (`m0.Timer` is the frontend's spelling
             // for a class declared in a non-entry module).
-            const display = info.decl?.name?.text ?? info.def.name.replace(/^%/, "");
+            const display = info.def.jsName ?? info.decl?.name?.text ?? info.def.name.replace(/^%/, "");
             // #private fields never render: they are not properties in any
             // observable way — Node's inspect omits them entirely (verified),
             // so a class whose only fields are private prints as `C {}`.
             const visible = info.def.fields.filter((f) => !f.name.startsWith("#"));
             if (visible.length === 0) {
-                body = [ret(strLit(`${display} {}`, loc))];
+                body = [ret(strLit(display === "" ? "{}" : `${display} {}`, loc))];
                 break;
             }
             const get = (field, type) => ({
@@ -927,7 +1043,7 @@ function inspectHelper(lowerer, t, loc) {
                 type,
                 loc,
             });
-            body = [depthGate(`[${display}]`), ...begin()];
+            body = [depthGate(display === "" ? "[Object]" : `[${display}]`), ...begin()];
             // def.fields carries layout order: the base chain first, then own —
             // exactly the own-property insertion order of a constructor that
             // assigns in declaration order (SEMANTICS.md 36's stance). SYMBOL-
@@ -948,7 +1064,7 @@ function inspectHelper(lowerer, t, loc) {
                 const key = symNames.has(f.name) ? symbolFieldDisplayName(f.name) : inspectKey(f.name);
                 body.push(entry(concatAll([strLit(`${key}: `, loc), child(f.type, get(f.name, f.type))], loc), boolLit(false, loc)));
             }
-            body.push(ret(end(strLit("", loc), strLit(`${display} {`, loc), strLit("}", loc), false, boolLit(false, loc))));
+            body.push(ret(end(strLit("", loc), strLit(display === "" ? "{" : `${display} {`, loc), strLit("}", loc), false, boolLit(false, loc))));
             break;
         }
         default:
@@ -1108,7 +1224,7 @@ export function lowerConsoleInspectArg(lowerer, node, value, surface, loc) {
     if (t.kind === "undefinedT" || t.kind === "nullT") {
         // The baked text ("undefined"/"null"): the operand is a literal or a
         // pure read, so dropping its evaluation loses nothing. Effectful
-        // unit-typed operands keep a fence — a silent skip is banned.
+        // unit-typed operands report SC1090 instead of being skipped.
         if (value.kind !== "unitLit" && !isSafeToRepeat(value)) {
             lowerer.unsupported("SC1090", node, `${surface} of an effectful '${lowerer.fmt(t)}'-typed expression (evaluate it first: const v = ...; ${surface}(v))`);
         }
@@ -1143,16 +1259,17 @@ export function lowerConsoleInspectArg(lowerer, node, value, surface, loc) {
 /* ── the callsite: options, direct function/class names ──────────────── */
 /** The parsed options literal: the resolved depth (numeric; Infinity for
  * `null`), with every non-default knob fenced by name. */
-function parseInspectOptions(lowerer, node, recursive) {
+function parseInspectOptions(lowerer, node, recursive, dir = false) {
+    const surface = dir ? "console.dir" : "util.inspect";
     if (!node || (ts.isIdentifier(node) && node.text === "undefined"))
         return 2;
     if (!ts.isObjectLiteralExpression(node)) {
-        lowerer.noLowering("util.inspect with a non-literal options argument", node, "the options must be an object literal ({ depth, colors: false, ... }) so the knobs resolve at compile time");
+        lowerer.noLowering(`${surface} with a non-literal options argument`, node, "the options must be an object literal ({ depth, colors: false, ... }) so the knobs resolve at compile time");
     }
     let depth = 2;
     for (const prop of node.properties) {
         if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) {
-            lowerer.noLowering("util.inspect options in this form", prop, "plain `key: literal` entries are the lowered options");
+            lowerer.noLowering(`${surface} options in this form`, prop, "plain `key: literal` entries are the lowered options");
         }
         const key = prop.name.text;
         const value = prop.initializer;
@@ -1178,28 +1295,34 @@ function parseInspectOptions(lowerer, node, recursive) {
             else if (!(ts.isIdentifier(value) && value.text === "undefined")) {
                 const n = numeric();
                 if (n === null) {
-                    lowerer.noLowering("util.inspect with a non-literal depth option", value, "depth must be a numeric literal (or null)");
+                    lowerer.noLowering(`${surface} with a non-literal depth option`, value, "depth must be a numeric literal (or null)");
                 }
                 depth = n;
             }
         }
         else if (key === "colors") {
             if (value.kind !== ts.SyntaxKind.FalseKeyword) {
-                lowerer.noLowering("util.inspect with colors: true", value, "ANSI styling has no lowering — only colors: false");
+                lowerer.noLowering(`${surface} with colors: true`, value, "ANSI styling has no lowering — only colors: false");
             }
         }
         else if (key === "compact") {
             if (numeric() !== 3) {
-                lowerer.noLowering("util.inspect with a non-default compact option", value, "only the default compact: 3 is lowered");
+                lowerer.noLowering(`${surface} with a non-default compact option`, value, "only the default compact: 3 is lowered");
             }
         }
         else if (key === "breakLength") {
             if (numeric() !== 80) {
-                lowerer.noLowering("util.inspect with a non-default breakLength option", value, "only the default breakLength: 80 is lowered");
+                lowerer.noLowering(`${surface} with a non-default breakLength option`, value, "only the default breakLength: 80 is lowered");
+            }
+        }
+        else if (dir && key === "customInspect") {
+            // console.dir's own default; only that value is lowered.
+            if (value.kind !== ts.SyntaxKind.FalseKeyword) {
+                lowerer.noLowering("console.dir with customInspect: true", value, "only customInspect: false (console.dir's default) is lowered");
             }
         }
         else {
-            lowerer.noLowering(`util.inspect with the '${key}' option`, prop, "the lowered options are depth (numeric literal or null), colors: false, compact: 3, and breakLength: 80");
+            lowerer.noLowering(`${surface} with the '${key}' option`, prop, `the lowered options are depth (numeric literal or null), colors: false, compact: 3, ${dir ? "breakLength: 80, and customInspect: false" : "and breakLength: 80"}`);
         }
     }
     return depth;
@@ -1249,16 +1372,25 @@ function lowerInspectCall(lowerer, expr, loc) {
     if (expr.arguments.length < 1 || expr.arguments.length > 2) {
         lowerer.noLowering(`util.inspect with ${expr.arguments.length} arguments`, expr, "the supported forms are inspect(value) and inspect(value, options)");
     }
-    const valueNode = expr.arguments[0];
+    return lowerInspectValue(lowerer, expr.arguments[0], expr.arguments[1], loc, false);
+}
+/** `inspect(value, options)` over one value node: the shared body of
+ * util.inspect and console.dir. console.dir is Node's `inspect(object,
+ * { customInspect: false, ...options })`; the only lowered value with a
+ * custom inspect hook is Buffer (its <Buffer ..> form), so that call
+ * fences Buffers and routes checked-dynamic values through the runtime
+ * walk that refuses a Buffer anywhere inside. */
+export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
+    const surface = dir ? "console.dir" : "util.inspect";
     // Inline function/class literals and direct declared names render as
     // their baked forms; other function-typed values fence below.
     const direct = directCallableInspect(lowerer, valueNode, loc);
     if (direct) {
-        parseInspectOptions(lowerer, expr.arguments[1], false);
+        parseInspectOptions(lowerer, optionsNode, false, dir);
         return direct;
     }
     if (ts.isArrowFunction(valueNode) || ts.isFunctionExpression(valueNode)) {
-        parseInspectOptions(lowerer, expr.arguments[1], false);
+        parseInspectOptions(lowerer, optionsNode, false, dir);
         return strLit(valueNode.kind === ts.SyntaxKind.FunctionExpression &&
             valueNode.name
             ? `[Function: ${valueNode.name.text}]`
@@ -1276,19 +1408,31 @@ function lowerInspectCall(lowerer, expr, loc) {
             tname === "NonSharedBuffer" ||
             tname.startsWith("Buffer<") ||
             tname.startsWith("NonSharedBuffer<");
+        if (dir) {
+            lowerer.noLowering(`console.dir of '${tname}' values`, valueNode, "console.dir disables custom inspection, and the typed-array rendering it falls back to has no lowering yet — use console.log");
+        }
         if (value.type.elem !== "u8" || !isBuffer) {
             lowerer.noLowering(`util.inspect of '${tname}' values`, valueNode, "Buffer's <Buffer ..> form is the lowered typed-array rendering; other typed arrays fence");
         }
-        const bufDepth = parseInspectOptions(lowerer, expr.arguments[1], false);
+        const bufDepth = parseInspectOptions(lowerer, optionsNode, false, dir);
         void bufDepth; // Buffers render fully at any depth (custom inspect)
         return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(2, loc), loc);
     }
     const walk = { recursive: false };
     const reason = inspectSupport(lowerer, value.type, new Set(), walk);
     if (reason !== null) {
-        lowerer.noLowering(`util.inspect of '${lowerer.fmt(value.type)}' values`, valueNode, reason);
+        lowerer.noLowering(`${surface} of '${lowerer.fmt(value.type)}' values`, valueNode, reason);
+    }
+    const depth = parseInspectOptions(lowerer, optionsNode, walk.recursive, dir);
+    if (dir && value.type.kind === "dyn") {
+        return {
+            kind: "libCall",
+            fn: "console.dirDyn",
+            args: [value, numLit(depth, loc)],
+            type: STRING,
+            loc,
+        };
     }
-    const depth = parseInspectOptions(lowerer, expr.arguments[1], walk.recursive);
     return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(depth, loc), loc);
 }
 /* ── util.format / util.formatWithOptions ────────────────────────────── */
@@ -1373,8 +1517,8 @@ function formatOArg(lowerer, node, depth, loc) {
  * ported exactly — the arg cursor, the args-exhausted guard, %c's
  * consume-and-drop), with per-static-type conversions. Non-literal
  * format strings lower only in the substitution-free shapes. */
-export function lowerFormatCall(lowerer, expr, loc, withOptions) {
-    const argNodes = [...expr.arguments];
+export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverride, literalPrefix = "") {
+    const argNodes = [...(argNodesOverride ?? expr.arguments)];
     if (withOptions) {
         const opts = argNodes.shift();
         if (!opts || !ts.isObjectLiteralExpression(opts) || opts.properties.length > 0) {
@@ -1402,7 +1546,9 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions) {
         }
         return concatAll(parts, loc);
     }
-    const fmt = first.text;
+    // A literal prefix joins the format text (console.assert's "Assertion
+    // failed: " — Node formats the joined string).
+    const fmt = literalPrefix + first.text;
     // Node's early return: a lone string first argument passes VERBATIM —
     // no substitution runs, "%%" stays "%%".
     if (argNodes.length === 1)
@@ -1454,7 +1600,8 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions) {
                 // context.actual)` — test/common's exit report): VALIDATE it as a
                 // number (dynCheck) and format. A non-number dyn value throws the
                 // catchable TypeError where Node would print its ToNumber (NaN
-                // for objects) — loud, never a silent wrong answer (SEMANTICS.md).
+                // for objects) — it throws instead of returning a wrong result
+                // (SEMANTICS.md).
                 if (value.type.kind === "dyn") {
                     return {
                         kind: "libCall",
@@ -1506,7 +1653,8 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions) {
                 // A checked-dynamic argument (`console.error('headers: %j',
                 // headers)` — the suite's http logging idiom): the runtime dyn
                 // walk stringifies JS-exactly (root undefined/function prints
-                // "undefined"; a handle in the tree throws the loud fence).
+                // "undefined"; a handle in the tree throws the "not supported yet"
+                // Error).
                 if (value.type.kind === "dyn") {
                     return { kind: "libCall", fn: "insp.jsonDyn", args: [value], type: STRING, loc };
                 }
@@ -1652,6 +1800,12 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
                 loc,
             };
         }
+        case "inherits":
+        case "deprecate":
+        case "callbackify":
+        case "debuglog":
+        case "debug":
+            return lowerUtilCallableCall(lowerer, expr, bi.member, loc);
         case "getSystemErrorMap": {
             if (expr.arguments.some(ts.isSpreadElement))
                 lowerer.noLowering("util.getSystemErrorMap with spread arguments", expr);
@@ -1735,6 +1889,71 @@ export function lowerUtilModuleCall(lowerer, expr, bi, loc) {
             return null;
     }
 }
+/** util.inherits/deprecate/callbackify/debuglog: every argument crosses as
+ * a checked-dynamic value, evaluated left to right before the runtime call
+ * (surplus arguments are evaluated and dropped). The function helpers
+ * answer native dyn wrappers; a static function slot checks the wrapper
+ * when it receives it, and dyn slots keep calling it with JS arity. */
+function lowerUtilCallableCall(lowerer, expr, member, loc) {
+    if (expr.arguments.some(ts.isSpreadElement))
+        lowerer.noLowering(`util.${member} with spread arguments`, expr);
+    const fn = member === "inherits"
+        ? "util.inherits"
+        : member === "deprecate"
+            ? "util.deprecate"
+            : member === "callbackify"
+                ? "util.callbackify"
+                : "util.debuglog";
+    const arity = member === "deprecate" ? 4 : member === "callbackify" ? 1 : 2;
+    // Program classes keep static prototypes: there is no function object
+    // whose prototype chain the runtime could relink or wrap.
+    const classArgs = member === "inherits" ? 2 : member === "deprecate" ? 1 : 0;
+    for (const arg of expr.arguments.slice(0, classArgs)) {
+        if (lowerer.mapTypeOf(lowerer.typeOf(arg))?.kind === "classval")
+            lowerer.noLowering(`util.${member} over a class constructor`, arg, member === "inherits"
+                ? "declare the subclass with extends"
+                : "deprecate a factory function or the class's call sites instead");
+    }
+    if (member === "callbackify" && callbackifyErrorExcludesNull(lowerer, expr))
+        lowerer.noLowering("util.callbackify into a callback whose error parameter excludes null", expr, "Node calls back with a null error on success; type the binding's callback as (err: NodeJS.ErrnoException | null, ...) => void");
+    const stmts = [];
+    const args = [];
+    for (let i = 0; i < arity; i++) {
+        const input = expr.arguments[i]
+            ? lowerer.lowerExprExpecting(expr.arguments[i], DYN)
+            : dynUndefinedExpr(loc);
+        const saved = lowerer.declareHiddenLocal("%utilInput", DYN);
+        stmts.push({ kind: "varDecl", localId: saved.id, init: input, loc });
+        args.push(varRef(saved.id, DYN, loc));
+    }
+    for (const arg of expr.arguments.slice(arity))
+        stmts.push({ kind: "exprStmt", expr: lowerer.lowerExpr(arg), loc });
+    const type = fn === "util.inherits" ? VOID : DYN;
+    const result = { kind: "libCall", fn, args, type, loc };
+    return { kind: "seqExpr", stmts, result, type: result.type, loc };
+}
+/** Whether the slot receiving a callbackify wrapper declares a callback
+ * whose first parameter cannot hold null. Some @types/node overloads type
+ * that error as NodeJS.ErrnoException, but Node passes null on success, and
+ * a statically typed callback parameter cannot receive a value its type
+ * excludes. Untyped (JavaScript or unknown) slots keep the wrapper dyn. */
+function callbackifyErrorExcludesNull(lowerer, expr) {
+    if (isJsSourceFile(expr.getSourceFile()))
+        return false;
+    const checker = lowerer.checker;
+    const slot = checker.getContextualType(expr) ?? lowerer.typeOf(expr);
+    const wrapper = checker.getCallSignatures(slot)[0];
+    const callbackSymbol = wrapper?.getParameters().at(-1);
+    if (!callbackSymbol)
+        return false;
+    const callback = checker.getCallSignatures(checker.getTypeOfSymbol(callbackSymbol))[0];
+    const errorSymbol = callback?.getParameters()[0];
+    if (!errorSymbol)
+        return false;
+    const error = checker.getTypeOfSymbol(errorSymbol);
+    const arms = error.isUnionType() ? ts.constituentTypes(error) : [error];
+    return !arms.some((arm) => (arm.flags & (ts.TypeFlags.Null | ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0);
+}
 /** util.parseArgs(config?): the configuration is ordinary JSON-safe data,
  * so it crosses into the runtime as a checked-dynamic tree. The native
  * parser returns the same tree-shaped result Node does (including token
@@ -1797,7 +2016,7 @@ function lowerParseArgsCall(lowerer, expr, loc) {
  * mustNotCall — `callSite.scriptName`:`callSite.lineNumber` in the
  * failure text — read a printable value instead of throwing). Argument
  * forms and TypeScript keep the SC2020 fence: a typed consumer asserting
- * real frames must fail loudly at compile time, not read placeholders. */
+ * real frames must fail at compile time instead of reading placeholders. */
 function lowerGetCallSitesCall(lowerer, expr, loc) {
     if (expr.arguments.length !== 0)
         return null;