@scriptc/compiler 0.1.2 → 0.1.4

package/dist/frontend/type-mapper.js

@@ -1,6 +1,7 @@
 import { InternalCompilerError } from "../errors.js";
 import * as ts from "./ts7/adapter.js";
-import { arrayOf, BOOL, bytesOf, canConvertToDyn, CHILD_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, JSVAL, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, UNDEFINED_T, VOID } from "../ir/ir.js";
+import { arrayOf, BOOL, bytesOf, canConvertToDyn, CHILD_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, JSVAL, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, UNDEFINED_T, VOID } from "../ir/ir.js";
+import { BIGINT_T } from "../ir/ir.js";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
 import { accessorSlotProp } from "../ir/ir.js";
 // typeKey moved to ir/ir.ts (the backend needs it too, for per-type
@@ -472,6 +473,8 @@ export function formatIrType(t, shapes, unions, seen = new Set()) {
             return "URLSearchParams";
         case "symbol":
             return "symbol";
+        case "bigint":
+            return "bigint";
         case "stats":
             return "Stats";
         case "fileHandle":
@@ -500,12 +503,20 @@ export function formatIrType(t, shapes, unions, seen = new Set()) {
             return "ClientRequest";
         case "secureCtx":
             return "SecureContext";
+        case "cryptoHash":
+            return "Hash";
+        case "cryptoHmac":
+            return "Hmac";
         case "fsWatcher":
             return "FSWatcher";
         case "childStream":
             return "Readable";
+        case "childWriter":
+            return "Writable";
         case "procStream":
             return "WriteStream";
+        case "moduleNs":
+            return `module namespace '${t.moduleId}'`;
         case "promise":
             return `Promise<${formatIrType(t.inner, shapes, unions, seen)}>`;
         case "generator":
@@ -728,6 +739,20 @@ function classExprNeverRegisters(decl) {
 }
 function mapTypeInner(type, ctx) {
     const { checker, unions, classNamer, resolveTypeParam } = ctx;
+    if (!ctx.dynamic) {
+        const moduleId = ctx.moduleNamespaceId?.(type) ?? null;
+        if (moduleId !== null)
+            return { kind: "moduleNs", moduleId };
+    }
+    // @types/node spells child_process.ExecFileException as an intersection
+    // type alias over two Error-derived metadata interfaces. The value is
+    // still one ordinary Error; recognize the owned alias before generic
+    // intersection mapping decomposes it into unsupported utility types.
+    const directAlias = type.getAliasSymbol();
+    if (directAlias?.name === "ExecFileException" &&
+        checker.declarationsOf(directAlias).some((decl) => ctx.isStdlibFile(decl.getSourceFile()))) {
+        return { kind: "object", className: "%Error" };
+    }
     if (resolveTypeParam && type.flags & ts.TypeFlags.TypeParameter) {
         const bound = resolveTypeParam(type);
         if (bound) {
@@ -831,6 +856,8 @@ function mapTypeInner(type, ctx) {
     // map to the symbol identity kind.
     if (flags & (ts.TypeFlags.ESSymbol | ts.TypeFlags.UniqueESSymbol))
         return SYMBOL_T;
+    if (flags & (ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral))
+        return BIGINT_T;
     // STANDALONE undefined (and void) map to VOID: return-type mapping flows
     // through here, and `(): void | undefined` functions must stay void.
     // Inside a union, undefined becomes the undefinedT unit ARM instead (see
@@ -935,15 +962,11 @@ function mapTypeInner(type, ctx) {
         })) {
         return ctx.dynamic ? JSVAL : null;
     }
-    // NOTE on module NAMESPACE types (`typeof import("./x.mjs")` — what a
-    // dynamic import resolves to): non-stdlib ones fall under the rule
-    // above (their declarations are the .d.ts SourceFiles themselves).
-    // Stdlib `declare module` namespaces ("fs", "path") deliberately stay
-    // unmapped: their members have STATIC lowerings keyed off import
-    // bindings (builtinImportOf), and a handle mapping would reroute
-    // `import * as path` member calls into the engine — dynamic imports of
-    // builtins get their handles from the import lowering's IR type
-    // instead.
+    // Module NAMESPACE types (`typeof import("./x.mjs")`) were claimed at
+    // the top by moduleNamespaceId when they name a compiled source module
+    // or supported builtin in a static build. Declaration-only package
+    // namespaces retain the npm rule above; dynamic builds retain their
+    // jsval import-handle path.
     // T[]: monomorphic arrays, recursively (number[][] works). An element type
     // that doesn't map (never from a context-free `[]`) makes the whole array
     // unsupported — null propagates. Record/object/union elements ride the
@@ -1094,7 +1117,7 @@ function mapTypeInner(type, ctx) {
     // no class identity of its own.
     if (widened.isIntersectionType()) {
         const HANDLE_KINDS = new Set([
-            "netServer", "netSocket", "httpReq", "httpRes", "httpClientReq", "dgramSocket",
+            "netServer", "netSocket", "httpReq", "httpRes", "httpClientReq", "dgramSocket", "childWriter",
             // process.stdout's own type IS the refined intersection
             // `WriteStream & { fd: 1 }` — the scalar stream kind rides the same
             // refinement rule.
@@ -1597,11 +1620,16 @@ function mapTypeInner(type, ctx) {
             ctx.isStdlibFile(d.getSourceFile()))) {
         return { kind: "spawnRes" };
     }
-    // child_process.ChildProcess: @types/node's class or the fallback
-    // declarations' interface. Provenance-checked like Stats.
-    if (psym?.name === "ChildProcess" &&
+    // child_process.ChildProcess and @types/node's stdio-refined return
+    // interfaces: all carry the same runtime child handle; the generic
+    // refinements only tell the checker which stdio properties are null.
+    if (psym !== undefined &&
+        (psym.name === "ChildProcess" ||
+            psym.name === "ChildProcessWithoutNullStreams" ||
+            psym.name === "ChildProcessByStdio") &&
         checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()))) {
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            isDeclaredInAmbientModule(d, "child_process"))) {
         return { kind: "child" };
     }
     // net.Server / net.Socket: @types/node's classes or the fallback
@@ -1638,6 +1666,15 @@ function mapTypeInner(type, ctx) {
             isDeclaredInAmbientModule(d, "tls"))) {
         return { kind: "secureCtx" };
     }
+    // crypto.Hash / crypto.Hmac: native incremental digest handles. Keep
+    // provenance module-qualified so user classes with these common names
+    // retain their ordinary structural/class representation.
+    if ((psym?.name === "Hash" || psym?.name === "Hmac") &&
+        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            isDeclaredInAmbientModule(d, "crypto"))) {
+        return psym.name === "Hash" ? CRYPTOHASH_T : CRYPTOHMAC_T;
+    }
     // fs.FSWatcher: the fs.watch handle (scr_watch.c). Module-checked like
     // net.Server — @types/node declares `interface FSWatcher extends
     // EventEmitter` inside `declare module "fs"`, and the shipped fallback
@@ -1675,6 +1712,21 @@ function mapTypeInner(type, ctx) {
                 isDeclaredInAmbientNamespace(d, "NodeJS")))) {
         return PROCSTREAM_T;
     }
+    // A piped child stdin writer. The fallback declarations give it the
+    // dedicated ChildStdin name; @types/node spells the same value as
+    // stream.Writable. As with stream.Readable below, unsupported producers
+    // of the broad @types class fence where they are constructed.
+    if ((psym?.name === "ChildStdin" &&
+        checker.declarationsOf(psym).some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            isDeclaredInAmbientModule(d, "child_process"))) ||
+        (psym?.name === "Writable" &&
+            checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+                ctx.isStdlibFile(d.getSourceFile()) &&
+                isNodeTypesPath(d.getSourceFile().fileName) &&
+                isDeclaredInAmbientModule(d, "stream")))) {
+        return { kind: "childWriter" };
+    }
     // The static node:stream classes (the shipped fallback declarations —
     // NOT @types/node, whose stream.Readable also types child stdio; under
     // @types/node the childStream mapping below keeps priority and the
@@ -2136,8 +2188,9 @@ function mapTypeInner(type, ctx) {
     // the same way — the completed-signature contract: the TYPE spells
     // `T | undefined`, the default's VALUE lives in the closure body's own
     // prologue (declareParams), and the undefined arm is what triggers it.
-    // Rest parameters keep the fence (a rest signature is never spellable
-    // as one completed arity).
+    // Rest parameters keep one typed-array ABI slot and mark the function
+    // type as typed-rest. Indirect call sites pack source arguments into that
+    // slot, so the native closure ABI remains fixed-width.
     // The chalk-style FUNCTION-WITH-PROPERTIES hybrid: an intersection of
     // exactly one callable part with plain data-property parts (`F & { bold:
     // F }` — Object.assign(fn, {...})'s type) maps to a RECORD carrying the
@@ -2178,11 +2231,16 @@ function mapTypeInner(type, ctx) {
             }
         }
         const params = [];
+        let typedRest = false;
         for (const p of sig.getParameters()) {
             const decl = checker.valueDeclarationOf(p);
-            if (decl && ts.isParameter(decl) && decl.dotDotDotToken) {
+            const rest = decl !== undefined && ts.isParameter(decl) && decl.dotDotDotToken !== undefined;
+            // JavaScript rest values retain the checked-dynamic/island runtime-
+            // arity ABI selected by lambdaSignature. Treating an inferred any[]
+            // declaration as a typed packed-array closure would bypass its boxed
+            // spread/error semantics and change coverage classification.
+            if (rest && decl !== undefined && isJsSourceFile(decl.getSourceFile()))
                 return null;
-            }
             const optional = decl !== undefined &&
                 ts.isParameter(decl) &&
                 (decl.questionToken !== undefined || decl.initializer !== undefined);
@@ -2198,6 +2256,11 @@ function mapTypeInner(type, ctx) {
             }
             if (!pt)
                 return null;
+            if (rest) {
+                if (pt.kind !== "array")
+                    return null;
+                typedRest = true;
+            }
             // `(value: void) => void` (Promise<void>'s resolve) is callable with
             // no arguments — a void param is dropped, not a mapping failure.
             if (pt.kind === "void")
@@ -2211,7 +2274,9 @@ function mapTypeInner(type, ctx) {
         const ret = retT.flags & ts.TypeFlags.Never ? VOID : mapType(retT, ctx);
         if (!ret)
             return null;
-        return funcOf(params, ret);
+        return typedRest
+            ? { kind: "func", params, ret, rest: true, restAbi: "typed" }
+            : funcOf(params, ret);
     }
     // Records: object types whose members are all data properties (shorthand
     // methods in type position count — they're func-typed fields) with
@@ -2237,13 +2302,15 @@ function mapTypeInner(type, ctx) {
     // NgrokChildProcess idiom — `spawn(...) as NgrokChildProcess`, declared
     // so tests can hand in mocks): every member is named on the lowered
     // ChildProcess surface AND at least two are the handle-defining ones
-    // (kill/on/stdout/stderr/unref/exitCode — a data record like
+    // (kill/on/stdin/stdout/stderr/unref/exitCode — a data record like
     // `{ pid: number }` never qualifies). The TYPE maps to the child
     // handle: in a compiled program the only VALUE producer is spawn
     // itself (a mock object literal in this slot fences at its
     // construction site), and every member the interface may declare is
-    // exactly a lowered child member, so uses typecheck against the
-    // interface and lower against the handle.
+    // exactly a lowered child member WITH the corresponding handle type, so
+    // uses typecheck against the interface and lower against the handle.
+    // Names alone are insufficient: a record of stdout/stderr callbacks is
+    // an ordinary data shape, not a child process.
     if (flags & ts.TypeFlags.Object &&
         callSigs.length === 0 &&
         psym !== undefined &&
@@ -2251,14 +2318,30 @@ function mapTypeInner(type, ctx) {
         checker.declarationsOf(psym).every((d) => ts.isInterfaceDeclaration(d) && !ctx.isStdlibFile(d.getSourceFile()))) {
         const CHILD_SURFACE = new Set([
             "pid", "exitCode", "killed", "kill", "on", "once", "off",
-            "removeListener", "unref", "ref", "stdout", "stderr",
+            "removeListener", "unref", "ref", "stdin", "stdout", "stderr",
+            "send", "connected", "disconnect",
         ]);
-        const CHILD_CORE = new Set(["kill", "on", "stdout", "stderr", "unref", "exitCode"]);
+        const CHILD_CORE = new Set(["kill", "on", "stdin", "stdout", "stderr", "unref", "exitCode", "send", "connected"]);
         const props = checker.getPropertiesOfType(widened);
         let core = 0;
+        const childMemberType = (p) => {
+            if (["kill", "on", "once", "off", "removeListener", "unref", "ref"].includes(p.name)) {
+                return checker.getCallSignatures(checker.getTypeOfSymbol(p)).length > 0;
+            }
+            const expected = p.name === "stdout" || p.name === "stderr" ? "childStream"
+                : p.name === "stdin" ? "childWriter"
+                    : p.name === "killed" ? "bool" : "f64";
+            const unit = p.name === "pid" ? "undefinedT" : p.name === "exitCode" || p.name === "stdin" || p.name === "stdout" || p.name === "stderr" ? "nullT" : null;
+            const mapped = mapType(checker.getTypeOfSymbol(p), ctx);
+            if (!mapped)
+                return false;
+            const arms = mapped.kind === "union" ? ctx.unions.get(mapped.unionId)?.arms : [mapped];
+            return arms !== undefined && arms.some((arm) => arm.kind === expected) &&
+                arms.every((arm) => arm.kind === expected || arm.kind === unit);
+        };
         const childShaped = props.length > 0 &&
             props.every((p) => {
-                if (!CHILD_SURFACE.has(p.name))
+                if (!CHILD_SURFACE.has(p.name) || !childMemberType(p))
                     return false;
                 if (CHILD_CORE.has(p.name))
                     core++;
@@ -2884,9 +2967,11 @@ function mapBrandedPrimitiveIntersection(widened, ctx) {
             return BOOL;
         if (base.flags & (ts.TypeFlags.ESSymbol | ts.TypeFlags.UniqueESSymbol))
             return SYMBOL_T;
+        if (base.flags & (ts.TypeFlags.BigInt | ts.TypeFlags.BigIntLiteral))
+            return BIGINT_T;
         if (base.flags & ts.TypeFlags.TypeParameter) {
             const bound = resolveTypeParam?.(base) ?? null;
-            if (bound && (bound.kind === "f64" || bound.kind === "string" || bound.kind === "bool" || bound.kind === "symbol")) {
+            if (bound && (bound.kind === "f64" || bound.kind === "bigint" || bound.kind === "string" || bound.kind === "bool" || bound.kind === "symbol")) {
                 contextResolutions++;
                 return bound;
             }
@@ -3513,8 +3598,9 @@ export function describeComponentBlocker(widened, ctx) {
         }
         return null;
     }
-    // Single-signature, non-generic function types: rest parameters, a
-    // parameter type, or the return type carries the failure. (Generic and
+    // Single-signature, non-generic function types: a parameter type or the
+    // return type carries the failure. Typed rest parameters use their array
+    // type here like any other completed ABI slot. (Generic and
     // overloaded signatures have their own fences — SC2005/SC2007 — and
     // badType runs those first.)
     const callSigs = checker.getCallSignatures(widened);
@@ -3530,10 +3616,6 @@ export function describeComponentBlocker(widened, ctx) {
             return `the function shape is supported, but its signature is variadic ('arguments'-reading), and a compiled signature is fixed-arity`;
         }
         for (const p of sig.getParameters()) {
-            const decl = checker.valueDeclarationOf(p);
-            if (decl !== undefined && ts.isParameter(decl) && decl.dotDotDotToken !== undefined) {
-                return `the function shape is supported, but its rest parameter '${p.name}' has no compiled calling convention yet (a compiled signature is fixed-arity)`;
-            }
             const pTs = checker.getTypeOfSymbol(p);
             if (!mapType(pTs, ctx)) {
                 return `the function shape is supported, but its parameter '${p.name}' has type '${text(pTs)}', which does not compile`;