@scriptc/compiler 0.4.0 → 0.4.1

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

@@ -1,4 +1,4 @@
-import { dynUndefinedExpr, boolLit, helperLoc, numLit, strLit, varRef } from "../../ir/build.js";
+import { dynUndefinedExpr, boolLit, helperLoc, nodeThrowExpr, numLit, strLit, varRef, } from "../../ir/build.js";
 import { builtinClassDynValueOf, builtinClassKindOf } from "./builtins/builtin-class-dyn.js";
 import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
@@ -85,13 +85,540 @@ function inspectKey(name) {
 function errorRenderable(info) {
     // The builtin classes' name/message/code live in runtime slots (the
     // ScrError prefix insp.error reads), not IR fields; only USER-declared
-    // fields are own properties the runtime rendering would miss. #private
-    // fields are NOT own properties — Node never prints them — so they
-    // don't disqualify.
-    if (!info.builtinError && info.def.fields.some((f) => !f.name.startsWith("#")))
-        return false;
+    // fields are own properties the runtime rendering would miss. A user
+    // class's layout repeats its builtin base's prefix fields, which are
+    // those same slots. #private fields are NOT own properties — Node never
+    // prints them — so they don't disqualify.
+    if (!info.builtinError) {
+        const inherited = new Set();
+        for (let c = info.base; c; c = c.base) {
+            if (c.builtinError || c.def.runtime)
+                for (const f of c.def.fields)
+                    inherited.add(f.name);
+        }
+        if (info.def.fields.some((f) => !f.name.startsWith("#") && !inherited.has(f.name)))
+            return false;
+    }
     return info.subclasses.every((s) => errorRenderable(s));
 }
+/** The accessors that change what Node reads for an error's header. The
+ * runtime renders the instance's own name and message slots. */
+const ERROR_HEADER_ACCESSORS = [
+    "get:name",
+    "set:name",
+    "get:message",
+    "set:message",
+    "get:stack",
+    "set:stack",
+];
+/** Whether Node's header for an instance of `info`'s hierarchy can differ
+ * from the runtime's slots: a program class among its ancestors or
+ * descendants declares a `name`, `message` or `stack` accessor, or the
+ * program writes a prototype's `name` or `message`. */
+function errorHeaderOverridden(lowerer, info) {
+    if (lowerer.prototypeMethodAccesses.has("name") || lowerer.prototypeMethodAccesses.has("message"))
+        return true;
+    const declares = (c) => !c.builtinError && !c.def.runtime && ERROR_HEADER_ACCESSORS.some((m) => c.methods.has(m));
+    for (let c = info.base; c; c = c.base)
+        if (declares(c))
+            return true;
+    const below = (c) => declares(c) || c.subclasses.some(below);
+    return below(info);
+}
+/** Error keys Node's error inspector folds into the base or hides. */
+const ERROR_SPECIAL_KEYS = new Set(["name", "message", "stack", "cause", "errors"]);
+/** The declared own (enumerable) fields of a user error class, in layout
+ * order (the base chain first). */
+function ownErrorFields(info) {
+    // The builtin bases' layout fields (name, message) are runtime slots the
+    // error base already renders, not own enumerable properties.
+    const builtin = new Set();
+    for (let c = info.base; c; c = c.base) {
+        if (c.builtinError || c.def.runtime)
+            for (const f of c.def.fields)
+                builtin.add(f.name);
+    }
+    return info.def.fields.filter((f) => isClassOwnEnumerableFieldName(f.name) && !builtin.has(f.name));
+}
+/** `info` and its descendants that declare fields, most-derived first (a
+ * runtime instance tests against its own class before an ancestor's). */
+function fieldedErrorClasses(info) {
+    const out = [];
+    const visit = (c) => {
+        for (const s of c.subclasses)
+            visit(s);
+        if (!c.builtinError && !c.def.runtime && ownErrorFields(c).length > 0)
+            out.push(c);
+    };
+    visit(info);
+    return out;
+}
+/** Why a fielded error class's own properties have no static rendering,
+ * or null when every field renders. `visiting` and `out` are the caller's
+ * inspectSupport walk: a field typed as the class itself (`next?: Chain`)
+ * is a recursive shape, not a new walk. */
+function fieldedErrorReason(lowerer, info, visiting = new Set(), out = { recursive: false }) {
+    const key = `error:${info.def.name}`;
+    if (visiting.has(key)) {
+        out.recursive = true;
+        return null;
+    }
+    visiting.add(key);
+    try {
+        for (let c = info; c && !c.builtinError && !c.def.runtime; c = c.base) {
+            // Node prints the own properties in creation order, which puts a
+            // declared `cause` among the fields; the cause renders after them.
+            if (c.fieldOrder.some((f) => f.errorCause))
+                return "its field 'cause' is one Node's error inspector treats specially";
+            // A JavaScript class's fields exist once its constructor creates them,
+            // which can be conditional; the layout reads every field.
+            if (c.decl && isJsSourceFile(c.decl.getSourceFile()) && ownErrorFields(c).length > 0)
+                return "its fields are JavaScript properties, which its constructor may not create";
+        }
+        for (const f of ownErrorFields(info)) {
+            if (ERROR_SPECIAL_KEYS.has(f.name))
+                return `its field '${f.name}' is one Node's error inspector treats specially`;
+            const why = inspectSupport(lowerer, f.type, visiting, out);
+            if (why !== null)
+                return `its field '${f.name}': ${why}`;
+        }
+        return null;
+    }
+    finally {
+        visiting.delete(key);
+    }
+}
+/** True when an instance of `c` can contain itself: its fields reach `c`
+ * or one of its bases, whose slots can hold a `c` (`next: Chain` in a
+ * subclass of Chain, a field typed as Error). */
+function errorInstanceReachesItself(lowerer, c) {
+    const holders = new Set();
+    for (let a = c; a; a = a.base)
+        holders.add(a.def.name);
+    const seen = new Set();
+    const walk = (u) => {
+        for (const x of typeConstituents(lowerer, u)) {
+            if (x.kind === "object" && holders.has(x.className))
+                return true;
+            const k = typeKey(x);
+            if (!seen.has(k)) {
+                seen.add(k);
+                if (walk(x))
+                    return true;
+            }
+        }
+        return false;
+    };
+    return walk({ kind: "object", className: c.def.name });
+}
+/** An error value whose runtime class may be a program-declared subclass,
+ * which may declare fields (`class Bailable extends Error { bail = false }`)
+ * or carry a `cause`: Node prints the error base (`[Bailable [Error]: m]`,
+ * the stackless form compiled errors use) followed by the own properties,
+ * `[Bailable [Error]: m] { bail: true }`, with the usual single-line/
+ * multi-line choice counting the base. Each program class (most-derived
+ * first) is an instanceof arm; other values keep the runtime's error
+ * rendering. Beyond the depth budget an instance with own properties
+ * prints `[Name]`, as Node does for any object with keys; one without
+ * prints its header. */
+function errorInspectHelper(lowerer, t, info, loc) {
+    const key = `insp.userError:${typeKey(t)}`;
+    const existing = lowerer.inspectHelpers.get(key);
+    if (existing)
+        return existing;
+    const name = `%util.insp.${lowerer.inspectHelpers.size}`;
+    lowerer.inspectHelpers.set(key, name);
+    const v = () => varRef("v.0", t, loc);
+    const r = () => varRef("r.0", F64, loc);
+    const d = () => varRef("d.0", F64, loc);
+    const rPlus1 = () => ({
+        kind: "bin",
+        op: "+",
+        left: r(),
+        right: numLit(1, loc),
+        type: F64,
+        loc,
+    });
+    const base = () => ({
+        kind: "libCall",
+        fn: "insp.error",
+        args: [v(), r(), d()],
+        type: STRING,
+        loc,
+    });
+    const error = () => lowerer.upcastTo(v(), "%Error");
+    const hasCause = () => ({
+        kind: "libCall",
+        fn: "insp.errorHasCause",
+        args: [error()],
+        type: BOOL,
+        loc,
+    });
+    const entry = (text) => ({
+        kind: "exprStmt",
+        expr: {
+            kind: "libCall",
+            fn: "insp.entry",
+            args: [text, boolLit(false, loc)],
+            type: VOID,
+            loc,
+        },
+        loc,
+    });
+    /** The own properties of an instance of `c`: its fields, then its
+     * `cause` (an assignment in the constructor or later, or the
+     * constructor's options, which Node lists last as `[cause]`). */
+    const propertiesArm = (c, display, fields) => {
+        const cls = { kind: "object", className: c.def.name };
+        const instance = c.def.name === t.className ? v() : { kind: "downcast", value: v(), type: cls, loc };
+        // A class whose fields can hold the instance itself (`next: Chain`)
+        // runs Node's circular machinery, as other cycle-capable objects do:
+        // an instance already on the traversal stack renders [Circular *N],
+        // before the depth answer, and the frame's text gets the <ref *N>
+        // prefix when the walk found it circular.
+        const onCycle = errorInstanceReachesItself(lowerer, c);
+        const circular = () => varRef("cc.0", F64, loc);
+        const arm = [
+            ...(onCycle
+                ? [
+                    {
+                        kind: "varDecl",
+                        localId: "cc.0",
+                        init: { kind: "libCall", fn: "insp.circCheck", args: [v()], type: F64, loc },
+                        loc,
+                    },
+                    {
+                        kind: "if",
+                        cond: {
+                            kind: "bin",
+                            op: ">",
+                            left: circular(),
+                            right: numLit(0, loc),
+                            type: BOOL,
+                            loc,
+                        },
+                        then: [
+                            {
+                                kind: "return",
+                                value: {
+                                    kind: "libCall",
+                                    fn: "insp.circular",
+                                    args: [circular()],
+                                    type: STRING,
+                                    loc,
+                                },
+                                loc,
+                            },
+                        ],
+                        else_: null,
+                        loc,
+                    },
+                ]
+                : []),
+            {
+                kind: "if",
+                cond: { kind: "bin", op: ">", left: r(), right: d(), type: BOOL, loc },
+                then: [{ kind: "return", value: strLit(`[${display}]`, loc), loc }],
+                else_: null,
+                loc,
+            },
+            {
+                kind: "varDecl",
+                localId: "base.0",
+                init: improvedErrorBase(lowerer, v(), base(), display, loc),
+                loc,
+            },
+            {
+                kind: "exprStmt",
+                expr: { kind: "libCall", fn: "insp.begin", args: [rPlus1()], type: VOID, loc },
+                loc,
+            },
+            ...(onCycle
+                ? [
+                    {
+                        kind: "exprStmt",
+                        expr: { kind: "libCall", fn: "insp.seenPush", args: [v()], type: VOID, loc },
+                        loc,
+                    },
+                ]
+                : []),
+        ];
+        for (const f of fields) {
+            const read = {
+                kind: "fieldGet",
+                obj: instance,
+                className: c.def.name,
+                field: f.name,
+                type: f.type,
+                loc,
+            };
+            arm.push(entry(concatAll([
+                strLit(`${inspectKey(f.name)}: `, loc),
+                inspectExpr(lowerer, f.type, read, rPlus1(), d(), loc),
+            ], loc)));
+        }
+        arm.push({
+            kind: "if",
+            cond: hasCause(),
+            then: [
+                entry({
+                    kind: "libCall",
+                    fn: "insp.errorCause",
+                    args: [error(), rPlus1(), d()],
+                    type: STRING,
+                    loc,
+                }),
+            ],
+            else_: null,
+            loc,
+        });
+        const ended = {
+            kind: "libCall",
+            fn: "insp.end",
+            args: [
+                varRef("base.0", STRING, loc),
+                strLit("{", loc),
+                strLit("}", loc),
+                rPlus1(),
+                boolLit(false, loc),
+                boolLit(false, loc),
+            ],
+            type: STRING,
+            loc,
+        };
+        arm.push({
+            kind: "return",
+            value: onCycle
+                ? { kind: "libCall", fn: "insp.refWrap", args: [v(), ended], type: STRING, loc }
+                : ended,
+            loc,
+        });
+        return arm;
+    };
+    const body = [];
+    for (const c of userErrorClasses(info)) {
+        const display = c.def.jsName ?? c.decl?.name?.text ?? c.def.name.replace(/^%/, "");
+        const fields = ownErrorFields(c);
+        const why = fields.length > 0 ? fieldedErrorReason(lowerer, c) : null;
+        let arm;
+        if (why !== null) {
+            // An instance of a subclass whose own properties have no rendering
+            // throws a named refusal instead of printing a partial object.
+            arm = [
+                {
+                    kind: "return",
+                    value: nodeThrowExpr(0, "SC2020", `inspecting a '${display}' error (${why}) is not supported yet`, STRING, loc),
+                    loc,
+                },
+            ];
+        }
+        else if (fields.length === 0) {
+            // A field-less program class: without a `cause` it has no own
+            // properties, and Node prints the header alone at any depth.
+            arm = [
+                {
+                    kind: "if",
+                    cond: { kind: "unary", op: "!", operand: hasCause(), type: BOOL, loc },
+                    then: [
+                        { kind: "return", value: improvedErrorBase(lowerer, v(), base(), display, loc), loc },
+                    ],
+                    else_: null,
+                    loc,
+                },
+                ...propertiesArm(c, display, fields),
+            ];
+        }
+        else {
+            arm = propertiesArm(c, display, fields);
+        }
+        if (c.def.name === t.className) {
+            body.push({ kind: "block", body: arm, loc });
+            break;
+        }
+        body.push({
+            kind: "if",
+            cond: { kind: "instanceOf", value: v(), className: c.def.name, type: BOOL, loc },
+            then: arm,
+            else_: null,
+            loc,
+        });
+    }
+    if (body.at(-1)?.kind !== "block")
+        body.push({ kind: "return", value: base(), loc });
+    const fn = {
+        name,
+        params: [
+            { localId: "v.0", name: "v", type: t },
+            { localId: "r.0", name: "r", type: F64 },
+            { localId: "d.0", name: "d", type: F64 },
+        ],
+        returnType: STRING,
+        locals: [
+            { id: "v.0", name: "v", type: t, mutable: false },
+            { id: "r.0", name: "r", type: F64, mutable: false },
+            { id: "d.0", name: "d", type: F64, mutable: false },
+            { id: "base.0", name: "base", type: STRING, mutable: false },
+            { id: "cc.0", name: "cc", type: F64, mutable: false },
+            { id: "name.0", name: "name", type: STRING, mutable: true },
+            { id: "raw.0", name: "raw", type: STRING, mutable: true },
+        ],
+        body,
+        loc,
+    };
+    // Dynamic stores (a JavaScript class's `this.x = ...` outside its
+    // declared fields, or a write through an untyped reference) add a
+    // property bag to a class after this helper was built. The rendering
+    // reads only a `cause` from it, so an instance whose bag holds another
+    // property throws a named refusal instead of printing a partial object.
+    lowerer.shapeOrderHelperFinalizers.push(() => {
+        const bagged = [info, ...userErrorClasses(info)].filter((c) => !c.builtinError &&
+            !c.def.runtime &&
+            c.def.fields.some((f) => f.name === DYN_CLASS_PROPERTIES));
+        if (bagged.length === 0)
+            return;
+        fn.body = [
+            ...bagged.map((c) => ({
+                kind: "if",
+                cond: {
+                    kind: "logical",
+                    op: "&&",
+                    left: { kind: "instanceOf", value: v(), className: c.def.name, type: BOOL, loc },
+                    right: {
+                        kind: "libCall",
+                        fn: "insp.errorBagHasProperties",
+                        args: [
+                            {
+                                kind: "fieldGet",
+                                obj: c.def.name === t.className
+                                    ? v()
+                                    : {
+                                        kind: "downcast",
+                                        value: v(),
+                                        type: { kind: "object", className: c.def.name },
+                                        loc,
+                                    },
+                                className: c.def.name,
+                                field: DYN_CLASS_PROPERTIES,
+                                type: DYN,
+                                loc,
+                            },
+                        ],
+                        type: BOOL,
+                        loc,
+                    },
+                    type: BOOL,
+                    loc,
+                },
+                then: [
+                    {
+                        kind: "return",
+                        value: nodeThrowExpr(0, "SC2020", `inspecting a '${c.def.jsName ?? c.def.name.replace(/^%/, "")}' error with properties created at run time is not supported yet`, STRING, loc),
+                        loc,
+                    },
+                ],
+                else_: null,
+                loc,
+            })),
+            ...body,
+        ];
+    });
+    lowerer.liftedFns.push(fn);
+    return name;
+}
+/** The program-declared classes among `info` and its descendants, most
+ * derived first (an instance tests against its own class before an
+ * ancestor's). Runtime-provided error classes are not among them. */
+function userErrorClasses(info) {
+    const out = [];
+    const visit = (c) => {
+        for (const s of c.subclasses)
+            visit(s);
+        if (!c.builtinError && !c.def.runtime)
+            out.push(c);
+    };
+    visit(info);
+    return out;
+}
+/** Node's improveStack over the stackless base (`[Error: m]`): when the
+ * instance's constructor name differs from its `name` and the name ends in
+ * "Error", the header names both — `[Bailable [Error]: m]`, or
+ * `[FetchError: m]` when the constructor name already contains it. */
+function improvedErrorBase(lowerer, value, base, display, loc) {
+    const str = (method, receiver, args, type) => ({
+        kind: "strIntrinsic",
+        method,
+        receiver,
+        args,
+        type,
+        loc,
+    });
+    const and = (left, right) => ({
+        kind: "logical",
+        op: "&&",
+        left,
+        right,
+        type: BOOL,
+        loc,
+    });
+    const eq = (left, right, negated = false) => ({
+        kind: "strEq",
+        negated,
+        left,
+        right,
+        type: BOOL,
+        loc,
+    });
+    const nameRef = () => varRef("name.0", STRING, loc);
+    const baseRef = () => varRef("raw.0", STRING, loc);
+    const after = () => ({
+        kind: "bin",
+        op: "+",
+        left: str("length", nameRef(), [], F64),
+        right: numLit(1, loc),
+        type: F64,
+        loc,
+    });
+    const next = () => str("charAt", baseRef(), [after()], STRING);
+    const cond = and(and(eq(nameRef(), strLit(display, loc), true), str("endsWith", nameRef(), [strLit("Error", loc)], BOOL)), and(str("startsWith", baseRef(), [concatAll([strLit("[", loc), nameRef()], loc)], BOOL), {
+        kind: "logical",
+        op: "||",
+        left: eq(next(), strLit(":", loc)),
+        right: eq(next(), strLit("]", loc)),
+        type: BOOL,
+        loc,
+    }));
+    const rest = () => str("slice", baseRef(), [after()], STRING);
+    const improved = {
+        kind: "ternary",
+        cond: str("includes", strLit(display, loc), [nameRef()], BOOL),
+        then: concatAll([strLit(`[${display}`, loc), rest()], loc),
+        else_: concatAll([strLit(`[${display} [`, loc), nameRef(), strLit("]", loc), rest()], loc),
+        type: STRING,
+        loc,
+    };
+    return {
+        kind: "seqExpr",
+        stmts: [
+            {
+                kind: "varDecl",
+                localId: "name.0",
+                init: {
+                    kind: "fieldGet",
+                    obj: lowerer.upcastTo(value, "%Error"),
+                    className: "%Error",
+                    field: "name",
+                    type: STRING,
+                    loc,
+                },
+                loc,
+            },
+            { kind: "varDecl", localId: "raw.0", init: base, loc },
+        ],
+        result: { kind: "ternary", cond, then: improved, else_: baseRef(), type: STRING, loc },
+        type: STRING,
+        loc,
+    };
+}
 function isErrorClass(lowerer, className) {
     if (RUNTIME_ERROR_CLASSES.has(className))
         return true;
@@ -200,9 +727,19 @@ function inspectSupport(lowerer, t, visiting, out) {
             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)";
+                if (userErrorClasses(info).length > 0 && errorHeaderOverridden(lowerer, info))
+                    return "error subclasses whose name, message or stack is an accessor or a prototype property have no inspect lowering yet";
+                if (errorRenderable(info))
+                    return null;
+                // Subclasses with declared fields render the error base followed
+                // by their own properties. The static class's own fields must
+                // render; a subclass whose fields cannot is a runtime refusal on
+                // its own instances only (see errorInspectHelper).
+                const own = fieldedErrorClasses(info).find((c) => c === info);
+                const ownWhy = own ? fieldedErrorReason(lowerer, own, visiting, out) : null;
+                if (ownWhy !== null)
+                    return `'${t.className.replace(/^%(m\d+\.)?/, "")}' error values (${ownWhy})`;
+                return null;
             }
             // A class with subclasses, or a JavaScript class, renders through its
             // checked-dynamic view, which names the instance's own class and holds
@@ -347,6 +884,16 @@ export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
                 };
             }
             if (isErrorClass(lowerer, t.className)) {
+                const info = lowerer.classes.get(t.className);
+                if (info && userErrorClasses(info).length > 0) {
+                    return {
+                        kind: "call",
+                        callee: errorInspectHelper(lowerer, t, info, loc),
+                        args: [value, recurse, depth],
+                        type: STRING,
+                        loc,
+                    };
+                }
                 return {
                     kind: "libCall",
                     fn: "insp.error",
@@ -452,8 +999,19 @@ function typeConstituents(lowerer, u) {
             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) ?? [];
+        case "object": {
+            const info = lowerer.classes.get(u.className);
+            if (!info)
+                return [];
+            const types = info.def.fields.map((f) => f.type);
+            // An error value can be an instance of a program-declared subclass,
+            // whose own fields its inspection renders (errorInspectHelper).
+            if (isErrorClass(lowerer, u.className))
+                for (const c of userErrorClasses(info))
+                    for (const f of ownErrorFields(c))
+                        types.push(f.type);
+            return types;
+        }
         default:
             return [];
     }