@scriptc/compiler 0.1.1 → 0.1.3

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,16 +503,22 @@ 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 "promise":
             return `Promise<${formatIrType(t.inner, shapes, unions, seen)}>`;
         case "generator":
-            return `Generator<${formatIrType(t.yieldT, shapes, unions, seen)}, ${formatIrType(t.retT, shapes, unions, seen)}, ${formatIrType(t.nextT, shapes, unions, seen)}>`;
+            return `${t.async ? "AsyncGenerator" : "Generator"}<${formatIrType(t.yieldT, shapes, unions, seen)}, ${formatIrType(t.retT, shapes, unions, seen)}, ${formatIrType(t.nextT, shapes, unions, seen)}>`;
         default: {
             const _exhaustive = t;
             void _exhaustive;
@@ -831,6 +840,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
@@ -1070,6 +1081,17 @@ function mapTypeInner(type, ctx) {
         fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
         return { kind: "record", shapeId: ctx.shapes.intern(fields, true) };
     }
+    // BRANDED PRIMITIVES (`string & { readonly __brand: "UserId" }`,
+    // `number & { readonly [tag]: "Meters" }`): the marker object is purely
+    // type-level, so the value rides the primitive's runtime representation.
+    // The recognizer is deliberately narrower than primitive-and-any-object:
+    // runtime-bearing class, callable, indexed, and non-literal data shapes
+    // remain intersections with no representation.
+    if (widened.isIntersectionType()) {
+        const brandedPrimitive = mapBrandedPrimitiveIntersection(widened, ctx);
+        if (brandedPrimitive)
+            return brandedPrimitive;
+    }
     // Class instances: the type's symbol is a class declared in the user's
     // file. The class NAME as a value has the *constructor* type — same
     // REFINED handle intersections — @types/node's idioms: `ServerResponse<
@@ -1083,7 +1105,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.
@@ -1254,6 +1276,20 @@ function mapTypeInner(type, ctx) {
     // (`x.toString()`) fences at each use site, never silently.
     if (isStdlibInterface("Object"))
         return DYN;
+    // NodeJS.Module / the shipped fallback's ScriptcModule: a process-lifetime
+    // scalar handle into the compiled CommonJS module registry. Module
+    // identity is numeric identity; its fields are served by the dedicated
+    // module lowering before generic number operations can observe the
+    // representation. The node:module class's merged instance interface is
+    // included, while unrelated user interfaces named Module stay structural.
+    if ((psym?.name === "ScriptcModule" || psym?.name === "Module") &&
+        checker.declarationsOf(psym).some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            (psym.name === "ScriptcModule" ||
+                isDeclaredInAmbientNamespace(d, "NodeJS") ||
+                isDeclaredInAmbientModule(d, "module")))) {
+        return F64;
+    }
     // events.EventEmitter: the runtime-provided emitter base class (the
     // Error-hierarchy precedent — user subclasses resolved through the
     // class-instance branch above). Both type layers declare it in the
@@ -1572,11 +1608,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
@@ -1613,6 +1654,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
@@ -1650,6 +1700,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
@@ -1811,9 +1876,9 @@ function mapTypeInner(type, ctx) {
             return null;
         return { kind: "promise", inner };
     }
-    // Generator<T, TReturn, TNext> (and the lib's IterableIterator<T, ...>,
-    // the older annotation spelling — Generator extends it): the sync
-    // generator kind. Channel normalization keeps the runtime honest:
+    // Generator<T, TReturn, TNext>, AsyncGenerator<T, TReturn, TNext> (and
+    // the lib's IterableIterator<T, ...>, the older sync annotation spelling):
+    // the generator kind. Channel normalization keeps the runtime honest:
     //   yield channel  — T must be a real value type (a generator that could
     //                    only yield undefined has no C value form); `never`
     //                    (a generator that never yields) rides the VOID
@@ -1829,7 +1894,7 @@ function mapTypeInner(type, ctx) {
     //                    argument — fenced at the call).
     // Mixed dyn/concrete channels stay unmapped: the shared result record's
     // value slot would need a dyn union arm, which does not exist.
-    if (isStdlibInterface("Generator") || isStdlibInterface("IterableIterator")) {
+    if (isStdlibInterface("Generator") || isStdlibInterface("AsyncGenerator") || isStdlibInterface("IterableIterator")) {
         const args = checker.getTypeArguments(widened);
         const channels = genChannels(args[0], args[1], args[2], ctx);
         if (!channels)
@@ -1838,7 +1903,11 @@ function mapTypeInner(type, ctx) {
         // `.next()` could never answer — mapped generators always resume.
         if (!genResultRecord(channels.yieldT, channels.retT, ctx.shapes, unions))
             return null;
-        return { kind: "generator", ...channels };
+        return {
+            kind: "generator",
+            ...(isStdlibInterface("AsyncGenerator") ? { async: true } : {}),
+            ...channels,
+        };
     }
     // IteratorResult<T, TReturn> — the checker's type of `g.next()` (an
     // alias for IteratorYieldResult<T> | IteratorReturnResult<TReturn>):
@@ -2208,7 +2277,7 @@ 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
@@ -2222,9 +2291,9 @@ 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",
         ]);
-        const CHILD_CORE = new Set(["kill", "on", "stdout", "stderr", "unref", "exitCode"]);
+        const CHILD_CORE = new Set(["kill", "on", "stdin", "stdout", "stderr", "unref", "exitCode"]);
         const props = checker.getPropertiesOfType(widened);
         let core = 0;
         const childShaped = props.length > 0 &&
@@ -2733,7 +2802,7 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
         shapeId: shapes.intern([
             { name: "done", type: BOOL },
             { name: "value", type: valueT },
-        ]),
+        ], false, undefined, ["value", "done"]),
     };
 }
 /** True when a checker type is inhabited ONLY by the unit values —
@@ -2830,6 +2899,92 @@ function mapHybridCallableIntersection(widened, ctx) {
     fields.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     return { kind: "record", shapeId: shapes.intern(fields, false, undefined, declaredOrder) };
 }
+/** A conventional primitive brand has one runtime-carrying primitive part
+ * and one or more phantom object parts whose fields are literal marker
+ * values. The marker can use a string or unique-symbol key, can be imported
+ * from a declaration file, and can be expressed through a generic alias;
+ * none of those facts changes the runtime value. Empty `{}` refinements are
+ * the marker-free form of the same primitive narrowing.
+ *
+ * Arbitrary primitive/object intersections do not erase here. A companion
+ * with a class identity, call/construct/index signature, accessor, or a
+ * non-literal value field might describe runtime behavior, so it retains the
+ * SC2008 refusal instead of borrowing the primitive representation. */
+function mapBrandedPrimitiveIntersection(widened, ctx) {
+    if (!widened.isIntersectionType())
+        return null;
+    const { checker, resolveTypeParam, resolveTypeParamTs } = ctx;
+    const primitivePart = (part) => {
+        const base = checker.getBaseTypeOfLiteralType(part);
+        if (base.flags & ts.TypeFlags.Number)
+            return F64;
+        if (base.flags & ts.TypeFlags.String)
+            return STRING;
+        if (base.flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral))
+            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 === "bigint" || bound.kind === "string" || bound.kind === "bool" || bound.kind === "symbol")) {
+                contextResolutions++;
+                return bound;
+            }
+        }
+        return null;
+    };
+    const markerValue = (value) => {
+        if (value.flags &
+            (ts.TypeFlags.StringLiteral |
+                ts.TypeFlags.NumberLiteral |
+                ts.TypeFlags.BigIntLiteral |
+                ts.TypeFlags.BooleanLiteral |
+                ts.TypeFlags.UniqueESSymbol |
+                ts.TypeFlags.EnumLiteral |
+                ts.TypeFlags.Never |
+                ts.TypeFlags.Undefined |
+                ts.TypeFlags.Void |
+                ts.TypeFlags.Null)) {
+            return true;
+        }
+        if (value.isUnionType())
+            return ts.constituentTypes(value).every(markerValue);
+        if (value.flags & ts.TypeFlags.TypeParameter) {
+            const bound = resolveTypeParamTs?.(value) ?? null;
+            if (bound) {
+                contextResolutions++;
+                return markerValue(bound);
+            }
+        }
+        return false;
+    };
+    let primitive = null;
+    let markerParts = 0;
+    for (const part of ts.constituentTypes(widened)) {
+        const mappedPrimitive = primitivePart(part);
+        if (mappedPrimitive) {
+            if (primitive && !typeEquals(primitive, mappedPrimitive))
+                return null;
+            primitive = mappedPrimitive;
+            continue;
+        }
+        const partSym = part.getSymbol();
+        const props = checker.getPropertiesOfType(part);
+        if ((part.flags & ts.TypeFlags.Object) === 0 ||
+            checker.getCallSignatures(part).length > 0 ||
+            checker.getConstructSignatures(part).length > 0 ||
+            checker.getIndexInfosOfType(part).length > 0 ||
+            (partSym !== undefined && (partSym.flags & ts.SymbolFlags.Class) !== 0) ||
+            props.some((prop) => (prop.flags & (ts.SymbolFlags.GetAccessor | ts.SymbolFlags.SetAccessor)) !== 0 ||
+                !markerValue(checker.getTypeOfSymbol(prop)))) {
+            return null;
+        }
+        markerParts++;
+    }
+    return primitive && markerParts > 0 ? primitive : null;
+}
 /** True for MAPPED-type results — `Partial<Config>`, `Record<"a", n>`,
  * whatever `Pick`/`Omit` reduce to. Their shape is computed by the checker,
  * not declared anywhere: the only declaration behind them is the utility