@scriptc/compiler 0.3.2 → 0.3.4

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

@@ -12,6 +12,12 @@ export declare function inspectExpr(lowerer: Lowerer, t: IrType, value: IrExpr,
  * <ref *N>/[Circular *N]); everything acyclic keeps the zero-cost path
  * (a value of an acyclic type can never repeat on its own path). */
 export declare function typeReachesItself(lowerer: Lowerer, t: IrType): boolean;
+/** True when a value of `t` can be cyclic: `t` or any type reachable from
+ * it reaches itself. */
+export declare function typeReachesCycle(lowerer: Lowerer, t: IrType): boolean;
+/** True when a value of `t` can hold a function: `t` or any type
+ * reachable from it is a function type. */
+export declare function typeReachesFunction(lowerer: Lowerer, t: IrType): boolean;
 /** One console.log/info/debug/error/warn argument OUTSIDE the direct
  * scalar set (number/string/boolean ride the ScrLogArg protocol
  * untouched, and dyn/function values have their own paths at the call

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, VOID, canConvertToDyn, canDynCheckTo, recordTextCodecClass, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
-import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, isUnitType, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, isDirentShape, isDynTypedRefType, recordTextCodecClass, shapeHasAccessorSlots, typeKey, } from "../../ir/ir.js";
+import { isSafeToDiscard, 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),
@@ -301,40 +357,7 @@ export function typeReachesItself(lowerer, t) {
     const root = typeKey(t);
     const seen = new Set();
     const walk = (u) => {
-        const constituents = [];
-        switch (u.kind) {
-            case "record": {
-                const shape = lowerer.shapes.get(u.shapeId);
-                if (!shape)
-                    return false;
-                constituents.push(...shape.fields.map((f) => f.type));
-                if (shape.indexValue)
-                    constituents.push(shape.indexValue);
-                break;
-            }
-            case "array":
-            case "set":
-                constituents.push(u.elem);
-                break;
-            case "map":
-                constituents.push(u.key, u.value);
-                break;
-            case "union": {
-                const def = lowerer.unions.get(u.unionId);
-                if (def)
-                    constituents.push(...def.arms);
-                break;
-            }
-            case "object": {
-                const info = lowerer.classes.get(u.className);
-                if (info)
-                    constituents.push(...info.def.fields.map((f) => f.type));
-                break;
-            }
-            default:
-                return false;
-        }
-        for (const c of constituents) {
+        for (const c of typeConstituents(lowerer, u)) {
             const k = typeKey(c);
             if (k === root)
                 return true;
@@ -348,6 +371,59 @@ export function typeReachesItself(lowerer, t) {
     };
     return walk(t);
 }
+/** True when a value of `t` can be cyclic: `t` or any type reachable from
+ * it reaches itself. */
+export function typeReachesCycle(lowerer, t) {
+    const seen = new Set();
+    const walk = (u) => {
+        const k = typeKey(u);
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        if (typeReachesItself(lowerer, u))
+            return true;
+        return typeConstituents(lowerer, u).some(walk);
+    };
+    return walk(t);
+}
+/** True when a value of `t` can hold a function: `t` or any type
+ * reachable from it is a function type. */
+export function typeReachesFunction(lowerer, t) {
+    const seen = new Set();
+    const walk = (u) => {
+        if (u.kind === "func")
+            return true;
+        const k = typeKey(u);
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return typeConstituents(lowerer, u).some(walk);
+    };
+    return walk(t);
+}
+/** The types a value of `u` holds directly. */
+function typeConstituents(lowerer, u) {
+    switch (u.kind) {
+        case "record": {
+            const shape = lowerer.shapes.get(u.shapeId);
+            if (!shape)
+                return [];
+            const fields = shape.fields.map((f) => f.type);
+            return shape.indexValue ? [...fields, shape.indexValue] : fields;
+        }
+        case "array":
+        case "set":
+            return [u.elem];
+        case "map":
+            return [u.key, u.value];
+        case "union":
+            return lowerer.unions.get(u.unionId)?.arms.slice() ?? [];
+        case "object":
+            return lowerer.classes.get(u.className)?.def.fields.map((f) => f.type) ?? [];
+        default:
+            return [];
+    }
+}
 /* ── the interned per-type helper ────────────────────────────────────── */
 /** `%util.insp.<n>(v, r, d): string` — formatValue over the static type:
  * empty composites answer their literals (before the depth check, Node's
@@ -599,6 +675,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 +1046,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 +1063,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 +1084,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 +1244,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))`);
         }
@@ -1484,7 +1620,8 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                 // 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",
@@ -1536,7 +1673,8 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                 // 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 };
                 }
@@ -1545,6 +1683,61 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                 }
                 return { kind: "jsonStringify", value, type: STRING, loc };
             }
+            case 102: {
+                // %f — parseFloat(String(arg)) formatted: a number keeps its value
+                // except -0, which String() prints as "0"; strings parse with the
+                // global parseFloat; booleans and unit values (void calls and
+                // null | undefined unions included) parse to NaN.
+                const value = lowerer.lowerExpr(node);
+                const format = (number) => ({
+                    kind: "libCall",
+                    fn: "insp.f64",
+                    args: [number],
+                    type: STRING,
+                    loc,
+                });
+                const parse = (text) => format({ kind: "libCall", fn: "num.parseFloat", args: [text], type: F64, loc });
+                if (value.type.kind === "f64")
+                    return format({
+                        kind: "bin",
+                        op: "+",
+                        left: value,
+                        right: numLit(0, loc),
+                        type: F64,
+                        loc,
+                    });
+                if (value.type.kind === "string")
+                    return parse(value);
+                if (value.type.kind === "dyn") {
+                    return parse({
+                        kind: "libCall",
+                        fn: "dyn.toStringCoerce",
+                        args: [value],
+                        type: STRING,
+                        loc,
+                    });
+                }
+                const unitArms = (t) => t.kind === "union" && (lowerer.unions.get(t.unionId)?.arms.every(isUnitType) ?? false);
+                if (value.type.kind === "bool" ||
+                    value.type.kind === "void" ||
+                    isUnitType(value.type) ||
+                    unitArms(value.type)) {
+                    // The argument still evaluates once, for its effects: the value
+                    // already lowered, as a statement (never a second lowering of the
+                    // node, whose lifted helpers and closures would be built twice).
+                    if (isSafeToDiscard(value))
+                        return strLit("NaN", loc);
+                    return {
+                        kind: "seqExpr",
+                        stmts: [{ kind: "exprStmt", expr: value, loc }],
+                        result: strLit("NaN", loc),
+                        type: STRING,
+                        loc,
+                    };
+                }
+                lowerer.noLowering(`util.format %f of '${lowerer.fmt(value.type)}' values`, node, "pass a number, string or boolean, or convert the argument with String() first");
+                return strLit("NaN", loc);
+            }
             case 79: // %O — inspect at the defaults
                 return formatOArg(lowerer, node, 2, loc);
             case 111: // %o — showHidden semantics; depth 4
@@ -1562,6 +1755,7 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                     case 100: // d
                     case 79: // O
                     case 111: // o
+                    case 102: // f
                     case 105: {
                         // i
                         const node = args[++a];
@@ -1571,9 +1765,6 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
                         lastPos = i + 1;
                         continue;
                     }
-                    case 102: // f — parseFloat's full grammar has no static lowering
-                        lowerer.noLowering("util.format %f", expr, "parseFloat has no native lowering");
-                        break;
                     case 99: // c — consumes its argument, contributes nothing
                         a += 1;
                         if (lastPos !== i - 1)
@@ -1898,7 +2089,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;