@scriptc/compiler 0.0.2 → 0.0.4

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

@@ -9,16 +9,16 @@ import { isJsSourceFile, locOf } from "../program.js";
 import { isGenericCallableMemberType, typeKey } from "../types.js";
 import { PoisonError, dynFallbackType, dynUndefinedExpr, importCallHandleType, jsFuncNameOf, newFnCtx } from "./lowerer.js";
 import { enforceLibBoundary } from "./lib-boundary.js";
-import { builtinFenceHintOf, builtinModuleFnOf, NARROW_FIRST } from "./surfaces.js";
+import { builtinFenceHintOf, builtinModuleFnOf } from "./surfaces.js";
 import { requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
 import { mixinFnShapeOf } from "./lower-mixins.js";
 import { bufEncoding, dynStringReceiver, lowerArrayFromCall, lowerDynArrayFilterCall, lowerDynArrayFlatMapCall, lowerGroupByStaticCall, lowerIteratorHelperCall, lowerObjectAssignIndexShape, lowerObjectFromEntriesCall, lowerObjectIterOverIndexShape, lowerRegexMethodCall, lowerStringMethodCall, lowerTupleReadMethodCall } from "./lower-containers.js";
-import { lowerChildStreamMethodCall, lowerDirentMethodCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerWatcherMethodCall } from "./lower-builtins.js";
+import { lowerChildStreamMethodCall, lowerDirentMethodCall, lowerPerfHooksCall, lowerProcStreamMethodCall, lowerReflectApplyCall, lowerWatcherMethodCall } from "./lower-builtins.js";
 import { lowerPromiseAllTupleCall, lowerPromiseRejectCall, probeLower, templateRawTextOf } from "./lower-exprs.js";
 import { httpClientFnBindingOf, isStreamUndefCallExpr, lowerHttpClientFnCall } from "./lower-server.js";
 import { EMITTER_API_MEMBERS, findGenericMethodOn, lowerClassGenericMethodCall, lowerStaticMethodCall } from "./lower-classes.js";
 import { emitterRooted, lowerEmitterMethodCall } from "./lower-emitter.js";
-import { lowerFormatCall } from "./lower-inspect.js";
+import { lowerConsoleInspectArg, lowerFormatCall } from "./lower-inspect.js";
 import { STREAM_API_MEMBERS, lowerStreamMethodCall, lowerStreamModuleCall, lowerStreamStaticCall, streamSidesOf } from "./lower-stream.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsPathPrefix, nsUndefRead } from "./lower-namespaces.js";
 import { declSymbolOf } from "./lower-modules.js";
@@ -730,9 +730,13 @@ export function collectGenericSignature(L, decl) {
     }
     // Only NAME syntax is checkable here; optional/default/rest shapes are
     // computed per call site from the resolved signature (lowerGenericCall).
+    // Binding-PATTERN parameters (`retry<T>(fn, { retries = 3 } = {})`)
+    // pass: declareParams desugars patterns per instance exactly as it
+    // does for non-generic functions.
     for (const param of decl.parameters) {
-        if (!ts.isIdentifier(param.name))
+        if (!ts.isIdentifier(param.name) && !ts.isObjectBindingPattern(param.name) && !ts.isArrayBindingPattern(param.name)) {
             L.unsupported("SC1031", param);
+        }
     }
     const nameText = decl.name?.text ?? "%default"; // nameless = the default export (checked by collectSignatureInner)
     const symbol = declSymbolOf(L, decl);
@@ -2235,14 +2239,16 @@ export function lowerCall(L, expr) {
     }
     const consoleMember = L.consoleCallMember(expr);
     if (consoleMember !== null) {
-        // console.log writes stdout; console.error and console.warn are one
-        // stream in Node (warn IS error) and write stderr with the exact same
-        // formatting. The ambient signature accepts (number | string |
-        // boolean)[], which a union of those arms satisfies — so tsc lets
-        // `console.log(u)` through and the fence lives here. A NARROWED use
-        // already lowered to the arm via maybeNarrow; only genuinely-union
-        // args are rejected.
+        // console.log/info/debug write stdout; console.error and console.warn
+        // are one stream in Node (warn IS error, info and debug ARE log) and
+        // write stderr with the exact same formatting. Node's formatter is
+        // formatWithOptions: string arguments print verbatim, numbers and
+        // booleans directly, and EVERYTHING else through util.inspect at the
+        // rest-args depth 2 — which the static inspect machinery renders
+        // here (arrays, records, unions, Maps/Sets, undefined/null, ...);
+        // shapes inspect cannot render keep honest per-argument fences.
         const surface = `console.${consoleMember}`;
+        const stdoutMember = consoleMember === "log" || consoleMember === "info" || consoleMember === "debug";
         // A LITERAL format string with %-specifiers and further arguments
         // (`console.log('Mismatched %s function calls. Expected %s, actual
         // %d.', name, seg, n)` — test/common's exit report): Node's console
@@ -2256,7 +2262,7 @@ export function lowerCall(L, expr) {
             const formatted = lowerFormatCall(L, expr, loc, false);
             return {
                 kind: "intrinsic",
-                name: consoleMember === "log" ? "console.log" : "console.error",
+                name: stdoutMember ? "console.log" : "console.error",
                 args: [formatted],
                 type: VOID,
                 loc,
@@ -2270,9 +2276,6 @@ export function lowerCall(L, expr) {
                 // are ToString (Node-exact), casts are validated: both honest.
                 L.unsupported("SC1090", a, `${surface} of 'any' values (wrap it: ${surface}(\`\${v}\`), or validate with 'as <type>' first)`);
             }
-            if (lowered.type.kind === "union") {
-                L.unsupported("SC1090", a, `union-typed ${surface} arguments (${NARROW_FIRST})`);
-            }
             // Checked-dynamic values carry their own shape, so the runtime
             // renders them exactly like Node's console formatter renders a
             // non-format argument: strings VERBATIM, everything else through
@@ -2311,19 +2314,22 @@ export function lowerCall(L, expr) {
                     loc,
                 };
             }
-            // With the fallback console the signature already restricts args to
-            // number | string | boolean (anything else is a type error); with
-            // @types/node's console.log(...any[]) everything typechecks, so the
-            // fence moves here.
-            if (lowered.type.kind !== "f64" && lowered.type.kind !== "string" && lowered.type.kind !== "bool") {
-                L.unsupported("SC1090", a, `${surface} of '${L.fmt(lowered.type)}' values ` +
-                    `(only number, string, and boolean arguments lower)`);
+            // number/string/boolean ride the ScrLogArg protocol directly (the
+            // runtime formats them Node-exactly — including -0).
+            if (lowered.type.kind === "f64" || lowered.type.kind === "string" || lowered.type.kind === "bool") {
+                return lowered;
             }
-            return lowered;
+            // Everything else renders through the static inspect machinery at
+            // the rest-args depth 2 (formatWithOptions): arrays, records,
+            // unions (a string arm prints VERBATIM — the console.log vs
+            // inspect distinction, per arm), Maps/Sets, plain undefined/null,
+            // regexes, symbols, error values, Buffers. Shapes inspect cannot
+            // render fence honestly with the reason.
+            return lowerConsoleInspectArg(L, a, lowered, surface, loc);
         });
         return {
             kind: "intrinsic",
-            name: consoleMember === "log" ? "console.log" : "console.error",
+            name: stdoutMember ? "console.log" : "console.error",
             args,
             type: VOID,
             loc,
@@ -2551,6 +2557,17 @@ export function lowerCall(L, expr) {
     if (ts.isPropertyAccessExpression(expr.expression) &&
         L.isIslandExpr(expr.expression.expression)) {
         const receiver = L.lowerExpr(expr.expression.expression);
+        // A checker-`any` receiver whose VALUE lives in the DOM (a
+        // checked-dynamic local behind the any-typed spelling — the JS
+        // WeakSet placeholder, rest-args arrays): the checked-dynamic
+        // method machinery owns it — receiver-kind dispatch, stored-member
+        // calls, honest fences — never an engine op over a dyn value.
+        if (receiver.type.kind === "dyn") {
+            const served = lowerDynReceiverMethodCall(L, expr, expr.expression);
+            if (served)
+                return served;
+            L.unsupported("SC1100", expr, `'.${expr.expression.name.text}()' calls through 'unknown'-valued receivers in dynamically-executed positions`);
+        }
         const args = expr.arguments.map((a) => L.jsvalIn(L.lowerExpr(a), a));
         const result = {
             kind: "jsOp", op: "callMethod", name: expr.expression.name.text,
@@ -2560,6 +2577,20 @@ export function lowerCall(L, expr) {
     }
     if (L.isIslandExpr(expr.expression)) {
         const callee = L.lowerExpr(expr.expression);
+        // A checker-`any` callee that LOWERED checked-dynamic (a dyn member
+        // chain's stored function): the DOM's own call — dynCall reads and
+        // calls the stored member with Node's is-not-a-function TypeError
+        // on refusal. Island-typed arguments meet the boundary pass's
+        // dynCall rule (no jsval→DOM bridge exists — the named fence).
+        if (callee.type.kind === "dyn") {
+            const args = expr.arguments.map((a) => L.lowerExprExpecting(a, DYN));
+            const calleeName = ts.isPropertyAccessExpression(expr.expression)
+                ? expr.expression.getText()
+                : ts.isIdentifier(expr.expression)
+                    ? expr.expression.text
+                    : "value";
+            return { kind: "dynCall", callee, calleeName, args, type: DYN, loc };
+        }
         const args = expr.arguments.map((a) => L.jsvalIn(L.lowerExpr(a), a));
         const result = { kind: "jsOp", op: "callFn", args: [callee, ...args], type: JSVAL, loc };
         return islandPrimitiveExit(L, expr, result);
@@ -2934,7 +2965,7 @@ export function lowerCall(L, expr) {
         if (nsMember) {
             // A builtin RE-EXPORT FACADE member (`import * as assert from
             // "./facade.js"` over `export { ok } from "node:assert"` —
-            // prettier's universal/assert): builtinMemberOf's alias chase
+            // a universal re-export facade): builtinMemberOf's alias chase
             // resolves the builtin module/member, and the spokes own the call
             // exactly as a direct builtin import. Ordinary user-module
             // members answer null there and resolve below.
@@ -3037,6 +3068,10 @@ export function lowerCall(L, expr) {
         // as named builtin imports — before anything below tries to lower
         // the namespace object itself as a receiver.
         L.lowerNamespaceBuiltinCall(expr, expr.expression) ??
+            // The node:perf_hooks spoke: performance.now() and its
+            // .bind(performance) function value over the runtime's
+            // process-start-anchored monotonic clock.
+            lowerPerfHooksCall(L, expr, expr.expression) ??
             // The composed crypto pattern (randomBytes(n).toString(enc))
             // — its receiver is a Buffer-typed CALL no other lowering claims.
             L.lowerCryptoComposedCall(expr, expr.expression) ??
@@ -5648,8 +5683,15 @@ function lowerObjectStaticCall(L, call, access) {
                     }
                     else if (others.length === 1) {
                         vt = others[0];
-                        const narrowTag = L.armTag(f.type.unionId, vt);
-                        value = { kind: "unionNarrow", unionId: f.type.unionId, tag: narrowTag, value: raw, type: vt, loc };
+                        // A UNIT other arm (`null | undefined` fields — the mixed-
+                        // defaults spread idiom; undefined was filtered above, so
+                        // the unit is null): units carry no payload, so the guarded
+                        // push writes the unit LITERAL — unionNarrow to a unit arm
+                        // (and unionWrap of a narrowed unit) is malformed IR; the
+                        // literal is the one legal unit spelling.
+                        value = isUnitType(vt)
+                            ? { kind: "unitLit", unit: "null", type: vt, loc }
+                            : { kind: "unionNarrow", unionId: f.type.unionId, tag: L.armTag(f.type.unionId, vt), value: raw, type: vt, loc };
                     }
                     else {
                         L.unsupported("SC1090", call, `Object.${member} over '${L.fmt(argIr)}' (field '${f.name}' is a multi-arm union that ` +
@@ -5740,6 +5782,7 @@ export function lowerFunction(L, decl) {
     ctx.isAsync = sig.isAsync === true;
     if (sig.generator !== undefined)
         ctx.generator = sig.generator;
+    const diagsBefore = L.diags.length;
     L.fnStack.push(ctx);
     try {
         const { params, prologue } = L.declareParams(decl.parameters, sig.params);
@@ -5773,11 +5816,57 @@ export function lowerFunction(L, decl) {
     }
     catch (e) {
         // A poison OUTSIDE the per-statement catches (a parameter DEFAULT
-        // whose initializer is fenced): the diagnostic is already recorded —
-        // the function skips, like a signature-blocked one, instead of
-        // killing the whole analysis.
+        // whose initializer is fenced, a parameter PATTERN over a class
+        // that never lowered): the diagnostic is already recorded — the
+        // function skips, like a signature-blocked one, instead of killing
+        // the whole analysis.
         if (!(e instanceof PoisonError))
             throw e;
+        // JS sources defer function-level poisons like statement fences
+        // (the sentence-walker idiom `({ parent: sentenceNode })` over the
+        // #private-fenced AstPath): the function compiles as its OWN
+        // runtimeFence — CALLING it throws the first captured diagnostic
+        // at the declaration's position — so a reachable-but-broken
+        // signature stops the RUN at its own site instead of the build.
+        // ICEs (SC9001) stay compile errors, exactly like lowerStmts.
+        if (isJsSourceFile(decl.getSourceFile()) &&
+            L.diagSink === null &&
+            L.diags.length > diagsBefore &&
+            !L.diags.slice(diagsBefore).some((d) => d.code === "SC9001")) {
+            const captured = L.diags.splice(diagsBefore);
+            L.runtimeFences.push(...captured);
+            // An ABI type naming a class that never REGISTERED (the sentence-
+            // walker idiom's path type — the #private fence) is fine to emit:
+            // callers CAN lower calls to this symbol (a same-typed param
+            // passes straight through — no construction needed), so the fence
+            // function must exist, and run()'s unregistered-class sweep
+            // rewrites every such slot to the inert f64 placeholder before
+            // emission — caller and fence stay ABI-consistent.
+            const first = captured[0];
+            const loc = locOf(decl);
+            const pos = ts.getLineAndCharacterOfPosition(L.program.getSourceFile(first.loc.file) ?? decl.getSourceFile(), first.loc.start);
+            const params = sig.params.map((p, i) => ({ localId: `%pf${i}`, name: `%pf${i}`, type: p.type }));
+            const fn = {
+                name: sig.name,
+                params,
+                returnType: bodyReturn,
+                locals: params.map((p) => ({ id: p.localId, name: p.name, type: p.type, mutable: false })),
+                body: [
+                    {
+                        kind: "runtimeFence",
+                        code: first.code,
+                        message: `${first.message} [${first.code} at ${first.loc.file}:${pos.line + 1}]`,
+                        loc,
+                    },
+                ],
+                loc,
+            };
+            if (sig.isAsync)
+                fn.async = true;
+            if (sig.generator !== undefined)
+                fn.generator = sig.generator;
+            return fn;
+        }
         return null;
     }
     finally {
@@ -6069,10 +6158,11 @@ export function bindingGenericFnInfoOf(L, decl, fnNode) {
     }
     // Only NAME syntax is checkable here; optional/default/rest shapes are
     // computed per instantiation from the resolved signature — exactly
-    // collectGenericSignature's rule.
+    // collectGenericSignature's rule, binding patterns included.
     for (const param of fnNode.parameters) {
-        if (!ts.isIdentifier(param.name))
+        if (!ts.isIdentifier(param.name) && !ts.isObjectBindingPattern(param.name) && !ts.isArrayBindingPattern(param.name)) {
             L.unsupported("SC1031", param);
+        }
     }
     const stmt = decl.parent.parent; // declarator → list → statement (nsPathPrefix wants the statement)
     const info = {