@scriptc/compiler 0.4.3 → 0.4.5

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

@@ -1,14 +1,17 @@
 import { keyedHelperName } from "./stable-names.js";
 import { perKeyOrder } from "./key-order-witness.js";
+import { classPrototypeView } from "./class-prototypes.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";
 import { unsignedHex } from "../../format-integer.js";
+import { jsFuncNameOf } from "./lowerer.js";
 import { isJsSourceFile } from "../program.js";
-import { BOOL, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, isUnitType, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, CLASS_FIELD_ATTRIBUTES_PREFIX, classDynViewSupported, DYN_CLASS_PROPERTIES, isClassOwnEnumerableFieldName, isDirentShape, isDynTypedRefType, recordTextCodecClass, shapeHasAccessorSlots, shapeKeyOrders, typeKey, } from "../../ir/ir.js";
+import { BOOL, CAUGHT, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, isUnitType, UNDEFINED_T, VOID, canConvertToDyn, canDynCheckTo, CLASS_FIELD_ATTRIBUTES_PREFIX, classDynViewSupported, DYN_CLASS_PROPERTIES, isClassOwnEnumerableFieldName, isDirentShape, isDynTypedRefType, recordTextCodecClass, shapeHasAccessorSlots, shapeKeyOrders, typeKey, } from "../../ir/ir.js";
+import { accessorCall, findMethodOn } from "./lower-classes.js";
 import { isSafeToDiscard, isSafeToRepeat } from "./expressions/evaluation-safety.js";
-import { symbolFieldDisplayName } from "./symbol-fields.js";
+import { symbolFieldDisplayName, TO_STRING_TAG_FIELD } from "./symbol-fields.js";
 import { eventTargetRootOf } from "./lower-event-target.js";
 import { dateRootOf } from "./builtins/date-classes.js";
 import { lowerSystemErrorMap } from "./lower-system-errors.js";
@@ -646,11 +649,7 @@ function inspectSupport(lowerer, t, visiting, out) {
         case "array":
             return inspectSupport(lowerer, t.elem, visiting, out);
         case "bytes":
-            // A Uint8Array and a Buffer share the u8 representation and print
-            // differently; the other element kinds are never Buffers.
-            return t.elem === "u8"
-                ? "Uint8Array and Buffer values inside composites have no inspect lowering yet (Buffer's <Buffer ..> form vs Uint8Array's is not recorded in the static type here)"
-                : null;
+            return null;
         case "record": {
             if (visiting.has(t.shapeId)) {
                 out.recursive = true;
@@ -786,7 +785,10 @@ function inspectSupport(lowerer, t, visiting, out) {
         }
         // Generator objects print through their checked capsule: Node's
         // `Object [Generator] {}`, or the tag of the iterator they implement.
+        // URLs and URLSearchParams print through their handles.
         case "generator":
+        case "url":
+        case "searchParams":
             return null;
         default:
             return `'${lowerer.fmt(t)}' values have no inspect lowering`;
@@ -819,6 +821,106 @@ 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) {
+    const render = inspectExprBody(lowerer, t, value, recurse, depth, loc);
+    // A top-level render through emitted helpers that can reach a refusal
+    // (the 'not supported yet' Error of insp.dyn) unwinds the inspector to
+    // its state before the render on every exit: the Error propagates out of
+    // the helpers before they close their frames.
+    if (render.kind !== "call" ||
+        recurse.kind !== "numLit" ||
+        recurse.value !== 0 ||
+        !inspectMayRefuse(lowerer, t))
+        return render;
+    return withInspectUnwind(lowerer, render, t, loc);
+}
+/** A top-level helper render (`call helper(v, r, d)`) through a lifted
+ * wrapper that takes insp.mark first and runs insp.unwind however the
+ * render ends: `try { return helper(v, r, d); } finally { insp.unwind(); }`.
+ * A seqExpr cannot hold the try. */
+function withInspectUnwind(lowerer, render, t, loc) {
+    const key = `unwind:${render.callee}`;
+    let name = lowerer.inspectHelpers.get(key);
+    if (name === undefined) {
+        name = keyedHelperName(lowerer, "%util.inspUnwound", key);
+        lowerer.inspectHelpers.set(key, name);
+        const params = [
+            { localId: "v.0", name: "v", type: t },
+            { localId: "r.0", name: "r", type: F64 },
+            { localId: "d.0", name: "d", type: F64 },
+        ];
+        const call = (fn) => ({
+            kind: "exprStmt",
+            expr: { kind: "libCall", fn, args: [], type: VOID, loc },
+            loc,
+        });
+        lowerer.liftedFns.push({
+            name,
+            params,
+            returnType: STRING,
+            locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+            body: [
+                call("insp.mark"),
+                {
+                    kind: "tryCatch",
+                    tryBody: [
+                        {
+                            kind: "return",
+                            value: {
+                                kind: "call",
+                                callee: render.callee,
+                                args: params.map((p) => varRef(p.localId, p.type, loc)),
+                                type: STRING,
+                                loc,
+                            },
+                            loc,
+                        },
+                    ],
+                    catchBody: null,
+                    catchLocalId: null,
+                    finallyBody: [call("insp.unwind")],
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { ...render, callee: name };
+}
+/** Whether inspecting a `t` value can end in an inspection refusal: `t`
+ * or a type reachable from it is a checked-dynamic value, a generator, a
+ * Dirent row or a class instance, or a record or array that can keep
+ * undeclared properties, which can render through a checked-dynamic view. */
+function inspectMayRefuse(lowerer, t) {
+    const seen = new Set();
+    const walk = (u) => {
+        if (u.kind === "dyn" || u.kind === "generator")
+            return true;
+        if (u.kind === "record") {
+            const shape = lowerer.shapes.get(u.shapeId);
+            if (shape && isDirentShape(shape))
+                return true;
+            // The kept source properties render through the checked view (the
+            // helper's source gate).
+            if (recordMayKeepSource(lowerer, u))
+                return true;
+        }
+        // So do an array's properties besides its elements.
+        if (u.kind === "array" && lowerer.dynConvertible(u))
+            return true;
+        // A class instance can render through its checked-dynamic view, which
+        // a helper built earlier may only learn at the end of lowering
+        // (classInspectsAddedProperties).
+        if (u.kind === "object")
+            return true;
+        const k = typeKey(u);
+        if (seen.has(k))
+            return false;
+        seen.add(k);
+        return typeConstituents(lowerer, u).some(walk);
+    };
+    return walk(t);
+}
+function inspectExprBody(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") {
@@ -866,9 +968,29 @@ export function inspectExpr(lowerer, t, value, recurse, depth, loc) {
                     loc,
                 };
             }
-            return { kind: "libCall", fn: "insp.buffer", args: [value], type: STRING, loc };
+            // A Uint8Array, a Buffer and a DataView share the u8 representation
+            // and print differently: the view's own flags pick.
+            return {
+                kind: "libCall",
+                fn: "insp.bytes",
+                args: [value, recurse, depth],
+                type: STRING,
+                loc,
+            };
         case "dyn":
             return { kind: "libCall", fn: "insp.dyn", args: [value, recurse, depth], type: STRING, loc };
+        // URLs and URLSearchParams render through their checked-dynamic
+        // handles: Node's `URL { href: ..., hash: ... }` and
+        // `URLSearchParams { 'a' => '1' }`.
+        case "url":
+        case "searchParams":
+            return {
+                kind: "libCall",
+                fn: "insp.dyn",
+                args: [lowerer.coerceToExpected(value, DYN), recurse, depth],
+                type: STRING,
+                loc,
+            };
         case "generator":
             return {
                 kind: "libCall",
@@ -1695,8 +1817,68 @@ function inspectHelper(lowerer, t, loc) {
             // 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) => isClassOwnEnumerableFieldName(f.name));
+            // A Symbol.toStringTag getter (an own tag field is listed instead)
+            // brackets the tag after the name, `Name [tag] {`, when it is a
+            // nonempty string other than the name. A getter that throws shows
+            // no tag, as in Node.
+            const tagGetter = info.fields.has(TO_STRING_TAG_FIELD)
+                ? null
+                : findMethodOn(lowerer, info, "get:sym:toStringTag");
+            let named = (plain) => strLit(plain, loc);
+            if (tagGetter?.sig.ret.kind === "string") {
+                const owner = tagGetter.declarer.def.name;
+                locals.push({ id: "tag.0", name: "tag", type: STRING, mutable: true }, { id: "tagError.0", name: "tagError", type: CAUGHT, mutable: false });
+                body.push({ kind: "varDecl", localId: "tag.0", init: strLit("", loc), loc }, {
+                    kind: "tryCatch",
+                    tryBody: [
+                        {
+                            kind: "assign",
+                            localId: "tag.0",
+                            value: accessorCall(lowerer, owner, "get:sym:toStringTag", lowerer.upcastTo(v(), owner), [], STRING, loc),
+                            loc,
+                        },
+                    ],
+                    catchBody: [],
+                    catchLocalId: "tagError.0",
+                    finallyBody: null,
+                    loc,
+                });
+                const tag = () => varRef("tag.0", STRING, loc);
+                const shown = {
+                    kind: "logical",
+                    op: "&&",
+                    left: {
+                        kind: "strEq",
+                        negated: true,
+                        left: tag(),
+                        right: strLit("", loc),
+                        type: BOOL,
+                        loc,
+                    },
+                    right: {
+                        kind: "strEq",
+                        negated: true,
+                        left: tag(),
+                        right: strLit(display, loc),
+                        type: BOOL,
+                        loc,
+                    },
+                    type: BOOL,
+                    loc,
+                };
+                const head = concatAll([strLit(`${display === "" ? "Object" : display} [`, loc), tag(), strLit("]", loc)], loc);
+                named = (plain, make) => ({
+                    kind: "ternary",
+                    cond: shown,
+                    then: make(head),
+                    else_: strLit(plain, loc),
+                    type: STRING,
+                    loc,
+                });
+            }
+            const after = (text) => (head) => concatAll([head, strLit(text, loc)], loc);
             if (visible.length === 0) {
-                body = [ret(strLit(display === "" ? "{}" : `${display} {}`, loc))];
+                body.push(ret(named(display === "" ? "{}" : `${display} {}`, after(" {}"))));
                 break;
             }
             const get = (field, type) => ({
@@ -1707,7 +1889,15 @@ function inspectHelper(lowerer, t, loc) {
                 type,
                 loc,
             });
-            body = [depthGate(display === "" ? "[Object]" : `[${display}]`), ...begin()];
+            body.push({
+                kind: "if",
+                cond: { kind: "bin", op: ">", left: r(), right: d(), type: BOOL, loc },
+                then: [
+                    ret(named(display === "" ? "[Object]" : `[${display}]`, (head) => concatAll([strLit("[", loc), head, strLit("]", loc)], loc))),
+                ],
+                else_: null,
+                loc,
+            }, ...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-
@@ -1728,7 +1918,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 === "" ? "{" : `${display} {`, loc), strLit("}", loc), false, boolLit(false, loc))));
+            body.push(ret(end(strLit("", loc), named(display === "" ? "{" : `${display} {`, after(" {")), strLit("}", loc), false, boolLit(false, loc))));
             break;
         }
         default:
@@ -1957,15 +2147,17 @@ export function lowerConsoleInspectArg(lowerer, node, value, surface, loc) {
             lowerer.unsupported("SC1090", node, `${surface} of '${tname}' values (Buffer and the numeric typed arrays are the lowered byte renderings; DataView has none yet)`);
         }
         if (!isBufferTypeName(tname)) {
+            // A u8 value the checker types as a Uint8Array may still hold a
+            // Buffer, which Node prints as one: the view's flags pick.
             return {
                 kind: "libCall",
-                fn: "insp.typedArray",
+                fn: t.elem === "u8" ? "insp.bytes" : "insp.typedArray",
                 args: [value, numLit(0, loc), numLit(2, loc)],
                 type: STRING,
                 loc,
             };
         }
-        return inspectExpr(lowerer, t, value, numLit(0, loc), numLit(2, loc), loc);
+        return { kind: "libCall", fn: "insp.buffer", args: [value], type: STRING, loc };
     }
     if (t.kind === "void") {
         // Node prints "undefined" for a void call's result; a void expression
@@ -2076,35 +2268,49 @@ function parseInspectOptions(lowerer, node, recursive, dir = false) {
 }
 /** A render under non-default breakLength/compact/sorted: the value is evaluated
  * first, the layout applies to this render only, and the defaults return
- * afterwards. */
-function withInspectLayout(lowerer, options, value, render, loc) {
+ * however the render ends, an inspection refusal included. The render runs
+ * in a lifted function, `(v) => { insp.layout(...); try { return render(v); }
+ * finally { insp.layout(80, 3, false); } }`, since a seqExpr cannot hold the
+ * try; `tag` names the render for the function's key. */
+function withInspectLayout(lowerer, options, value, tag, render, loc) {
     if (options.breakLength === 80 && options.compact === 3 && !options.sorted)
         return render(value);
-    const input = lowerer.declareHiddenLocal("%inspectInput", value.type);
-    const text = lowerer.declareHiddenLocal("%inspectText", STRING);
-    const layout = (breakLength, compact, sorted) => ({
-        kind: "exprStmt",
-        expr: {
-            kind: "libCall",
-            fn: "insp.layout",
-            args: [numLit(breakLength, loc), numLit(compact, loc), boolLit(sorted, loc)],
-            type: VOID,
+    const key = `layout:${tag}:${typeKey(value.type)}:${options.breakLength}:${options.compact}:${options.sorted}:${options.depth}`;
+    let name = lowerer.inspectHelpers.get(key);
+    if (name === undefined) {
+        name = keyedHelperName(lowerer, "%util.inspLayout", key);
+        lowerer.inspectHelpers.set(key, name);
+        const layout = (breakLength, compact, sorted) => ({
+            kind: "exprStmt",
+            expr: {
+                kind: "libCall",
+                fn: "insp.layout",
+                args: [numLit(breakLength, loc), numLit(compact, loc), boolLit(sorted, loc)],
+                type: VOID,
+                loc,
+            },
             loc,
-        },
-        loc,
-    });
-    return {
-        kind: "seqExpr",
-        stmts: [
-            { kind: "varDecl", localId: input.id, init: value, loc },
-            layout(options.breakLength, options.compact, options.sorted),
-            { kind: "varDecl", localId: text.id, init: render(varRef(input.id, value.type, loc)), loc },
-            layout(80, 3, false),
-        ],
-        result: varRef(text.id, STRING, loc),
-        type: STRING,
-        loc,
-    };
+        });
+        lowerer.liftedFns.push({
+            name,
+            params: [{ localId: "v.0", name: "v", type: value.type }],
+            returnType: STRING,
+            locals: [{ id: "v.0", name: "v", type: value.type, mutable: false }],
+            body: [
+                layout(options.breakLength, options.compact, options.sorted),
+                {
+                    kind: "tryCatch",
+                    tryBody: [{ kind: "return", value: render(varRef("v.0", value.type, loc)), loc }],
+                    catchBody: null,
+                    catchLocalId: null,
+                    finallyBody: [layout(80, 3, false)],
+                    loc,
+                },
+            ],
+            loc,
+        });
+    }
+    return { kind: "call", callee: name, args: [value], type: STRING, loc };
 }
 /** `util.inspect(fn)` / `util.inspect(Cls)` over a DIRECT identifier
  * naming a declared function or class: the name is compile-time truth,
@@ -2132,6 +2338,13 @@ function directCallableInspect(lowerer, node, loc) {
     const decl = sym.declarations[0];
     if (!decl)
         return null;
+    // A JavaScript function can hold own properties (`f.x = 1`, computed
+    // keys), which the runtime walk prints after its name.
+    if (isJsSourceFile(node.getSourceFile())) {
+        const type = lowerer.mapTypeOf(lowerer.typeOf(node));
+        if (type?.kind === "func" && lowerer.dynConvertible(type))
+            return null;
+    }
     if (ts.isFunctionDeclaration(decl) && decl.name) {
         return strLit(`[Function: ${decl.name.text}]`, loc);
     }
@@ -2175,7 +2388,15 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
             ? `[Function: ${valueNode.name.text}]`
             : "[Function (anonymous)]", loc);
     }
-    const value = lowerer.lowerExpr(valueNode);
+    let value = lowerer.lowerExpr(valueNode);
+    // A JavaScript function renders through the runtime walk, which prints
+    // its own properties after its name.
+    if (value.type.kind === "func" &&
+        isJsSourceFile(valueNode.getSourceFile()) &&
+        lowerer.dynConvertible(value.type)) {
+        const name = jsFuncNameOf(valueNode);
+        value = { kind: "dynFrom", value, type: DYN, ...(name !== null ? { fnName: name } : {}), loc };
+    }
     if (value.type.kind === "bytes") {
         // One runtime representation serves Buffer AND Uint8Array; their
         // renderings differ (<Buffer aa> vs Uint8Array(1) [ 170 ]), so the
@@ -2193,16 +2414,18 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
         if (!isBuffer) {
             // A numeric typed array: Uint8Array(n) [ ... ] under the depth and
             // layout options.
-            return withInspectLayout(lowerer, options, value, (input) => ({
+            return withInspectLayout(lowerer, options, value, "typedArray", (input) => ({
                 kind: "libCall",
-                fn: "insp.typedArray",
+                fn: value.type.kind === "bytes" && value.type.elem === "u8"
+                    ? "insp.bytes"
+                    : "insp.typedArray",
                 args: [input, numLit(0, loc), numLit(options.depth, loc)],
                 type: STRING,
                 loc,
             }), loc);
         }
         // Buffers render fully at any depth and on one line (custom inspect).
-        return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(2, loc), loc);
+        return { kind: "libCall", fn: "insp.buffer", args: [value], type: STRING, loc };
     }
     const walk = { recursive: false };
     const reason = inspectSupport(lowerer, value.type, new Set(), walk);
@@ -2212,7 +2435,7 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
     const options = parseInspectOptions(lowerer, optionsNode, walk.recursive, dir);
     const depth = options.depth;
     if (dir && value.type.kind === "dyn") {
-        return withInspectLayout(lowerer, options, value, (input) => ({
+        return withInspectLayout(lowerer, options, value, "dirDyn", (input) => ({
             kind: "libCall",
             fn: "console.dirDyn",
             args: [input, numLit(depth, loc)],
@@ -2220,7 +2443,7 @@ export function lowerInspectValue(lowerer, valueNode, optionsNode, loc, dir) {
             loc,
         }), loc);
     }
-    return withInspectLayout(lowerer, options, value, (input) => inspectExpr(lowerer, value.type, input, numLit(0, loc), numLit(depth, loc), loc), loc);
+    return withInspectLayout(lowerer, options, value, "inspect", (input) => inspectExpr(lowerer, value.type, input, numLit(0, loc), numLit(depth, loc), loc), loc);
 }
 /* ── util.format / util.formatWithOptions ────────────────────────────── */
 /** One argument as format's %s conversion (Node: numbers via
@@ -2283,10 +2506,21 @@ function formatSArg(lowerer, node, depth, loc) {
     return inspectExpr(lowerer, t, value, numLit(0, loc), numLit(depth, loc), loc);
 }
 /** %O (depth 2) / %o (showHidden, depth 4) — inspect with the spec's
- * option deltas; %o fences over arrays (showHidden adds their hidden
- * [length] entry, which has no lowering). */
+ * option deltas. A checked-dynamic argument renders through the runtime's
+ * showHidden walk; static %o fences over arrays and nested dynamic values
+ * (showHidden adds an array's hidden [length] entry, which the static
+ * rendering has no lowering for). */
 function formatOArg(lowerer, node, depth, loc) {
     const value = lowerer.lowerExpr(node);
+    if (depth === 4 && value.type.kind === "dyn") {
+        return {
+            kind: "libCall",
+            fn: "insp.dynHidden",
+            args: [value, numLit(4, loc)],
+            type: STRING,
+            loc,
+        };
+    }
     if (value.type.kind === "bytes") {
         lowerer.noLowering(`util.format %${depth === 4 ? "o" : "O"} of typed-array values`, node, "pass util.inspect(buf) explicitly");
     }
@@ -2294,8 +2528,8 @@ function formatOArg(lowerer, node, depth, loc) {
     const reason = inspectSupport(lowerer, value.type, new Set(), walk);
     if (reason !== null)
         lowerer.noLowering(`util.format %${depth === 4 ? "o" : "O"} of '${lowerer.fmt(value.type)}' values`, node, reason);
-    if (depth === 4 && typeTreeHasArray(lowerer, value.type, new Set())) {
-        lowerer.noLowering("util.format %o over arrays", node, "%o renders with showHidden (arrays gain a hidden [length] entry) — use %O for the default rendering");
+    if (depth === 4 && typeTreeHasHidden(lowerer, value.type, new Set())) {
+        lowerer.noLowering("util.format %o over arrays", node, "%o renders with showHidden (arrays gain a hidden [length] entry) — use %O for the default rendering, or pass the value as unknown");
     }
     return inspectExpr(lowerer, value.type, value, numLit(0, loc), numLit(depth, loc), loc);
 }
@@ -2648,9 +2882,10 @@ export function lowerFormatCall(lowerer, expr, loc, withOptions, argNodesOverrid
     return concatAll(parts, loc);
 }
 /** Arrays anywhere in the tree — the %o (showHidden) gate. */
-function typeTreeHasArray(lowerer, t, visiting) {
+function typeTreeHasHidden(lowerer, t, visiting) {
     switch (t.kind) {
         case "array":
+        case "dyn":
             return true;
         case "record": {
             if (visiting.has(t.shapeId))
@@ -2659,23 +2894,23 @@ function typeTreeHasArray(lowerer, t, visiting) {
             const shape = lowerer.shapes.get(t.shapeId);
             if (shape?.tuple)
                 return true;
-            return (shape?.fields ?? []).some((f) => typeTreeHasArray(lowerer, f.type, visiting));
+            return (shape?.fields ?? []).some((f) => typeTreeHasHidden(lowerer, f.type, visiting));
         }
         case "map":
-            return (typeTreeHasArray(lowerer, t.key, visiting) || typeTreeHasArray(lowerer, t.value, visiting));
+            return (typeTreeHasHidden(lowerer, t.key, visiting) || typeTreeHasHidden(lowerer, t.value, visiting));
         case "set":
-            return typeTreeHasArray(lowerer, t.elem, visiting);
+            return typeTreeHasHidden(lowerer, t.elem, visiting);
         case "union": {
             if (visiting.has(t.unionId))
                 return false;
             visiting.add(t.unionId);
-            return (lowerer.unions.get(t.unionId)?.arms ?? []).some((a) => typeTreeHasArray(lowerer, a, visiting));
+            return (lowerer.unions.get(t.unionId)?.arms ?? []).some((a) => typeTreeHasHidden(lowerer, a, visiting));
         }
         case "object": {
             if (visiting.has(t.className))
                 return false;
             visiting.add(t.className);
-            return (lowerer.classes.get(t.className)?.def.fields ?? []).some((f) => typeTreeHasArray(lowerer, f.type, visiting));
+            return (lowerer.classes.get(t.className)?.def.fields ?? []).some((f) => typeTreeHasHidden(lowerer, f.type, visiting));
         }
         case "bytes":
             return true;
@@ -2831,8 +3066,13 @@ function lowerUtilCallableCall(lowerer, expr, member, loc) {
     const builtinBase = member === "inherits" && expr.arguments.nodes[1] !== undefined
         ? builtinClassKindOf(lowerer, expr.arguments.nodes[1])
         : null;
+    // A superCtor class whose prototype has a complete view (a module-level
+    // JavaScript class named directly) passes that view to the runtime.
+    const superView = member === "inherits" && builtinBase === null && expr.arguments.nodes[1] !== undefined
+        ? classPrototypeView(lowerer, expr.arguments.nodes[1], loc)
+        : null;
     for (const [index, arg] of expr.arguments.nodes.slice(0, classArgs).entries()) {
-        if (index === 1 && builtinBase !== null)
+        if (index === 1 && (builtinBase !== null || superView !== null))
             continue;
         if (lowerer.mapTypeOf(lowerer.typeOf(arg))?.kind === "classval")
             lowerer.noLowering(`util.${member} over a class constructor`, arg, member === "inherits"
@@ -2857,7 +3097,9 @@ function lowerUtilCallableCall(lowerer, expr, member, loc) {
     for (const arg of expr.arguments.nodes.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 };
+    const result = superView
+        ? { kind: "libCall", fn: "util.inheritsPrototype", args: [...args, superView], type, loc }
+        : { 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