@scriptc/compiler 0.2.6 → 0.2.8

package/dist/frontend/type-mapper.js

@@ -12,6 +12,11 @@ import { accessorSlotProp, recordTextCodecClass } from "../ir/ir.js";
 // helper interning); re-exported here so frontend call sites keep their
 // import path.
 export { typeKey };
+/** The checker omits the erased receiver parameter from callable arity. */
+function runtimeParameterCount(parameters) {
+    const first = parameters[0];
+    return (parameters.length - (first && ts.isIdentifier(first.name) && first.name.text === "this" ? 1 : 0));
+}
 /** Empty JS object inference describes no fixed layout. Keep these values
  * in checked storage across fields, parameters and function signatures. */
 export function jsOpenObjectType(decl, type, shapes, unions) {
@@ -855,6 +860,36 @@ let mapTypeDepth = 0;
  * a bump between entry and exit stays fenced (recursive generic-open types
  * stay fenced instead of interning a per-context-wrong shape). */
 let contextResolutions = 0;
+/** worker_threads' Worker and MessagePort: owned runtime handles that keep
+ * their live object representation (DYN) wherever they are stored. */
+function isWorkerHandleSymbol(symbol, ctx) {
+    return ((symbol?.name === "Worker" || symbol?.name === "MessagePort") &&
+        ctx.checker
+            .declarationsOf(symbol)
+            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
+            ctx.isStdlibFile(d.getSourceFile()) &&
+            isDeclaredInAmbientModule(d, "worker_threads")));
+}
+/** True for a type built only from worker handles, null/undefined, and
+ * arrays of those: values that keep the live DYN representation. */
+export function isWorkerHandleType(type, ctx) {
+    const members = type.isUnionType() ? ts.constituentTypes(type) : [type];
+    let handle = false;
+    for (const member of members) {
+        if (member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined))
+            continue;
+        if (ctx.checker.isArrayType(member)) {
+            const element = ctx.checker.getTypeArguments(member)[0];
+            if (element === undefined || !isWorkerHandleType(element, ctx))
+                return false;
+        }
+        else if (!isWorkerHandleSymbol(member.getSymbol(), ctx)) {
+            return false;
+        }
+        handle = true;
+    }
+    return handle;
+}
 export function mapType(type, ctx) {
     if (mapTypeDepth >= MAP_TYPE_MAX_DEPTH)
         return null;
@@ -1325,6 +1360,9 @@ function mapTypeInner(type, ctx) {
     // runtime-bearing class, callable, indexed, and non-literal data shapes
     // remain intersections with no representation.
     if (widened.isIntersectionType()) {
+        const errorMetadata = mapErrorMetadataIntersection(widened, ctx);
+        if (errorMetadata)
+            return errorMetadata;
         const brandedPrimitive = mapBrandedPrimitiveIntersection(widened, ctx);
         if (brandedPrimitive)
             return brandedPrimitive;
@@ -1720,7 +1758,7 @@ function mapTypeInner(type, ctx) {
     // (fs/exec throw sites stamp `code`), so the type maps to the %Error
     // root — `err as NodeJS.ErrnoException` from an Error-typed value is a
     // no-op cast, error-typed listener params accept it, and the `.code`
-    // read has its own lowering (errno/syscall/path stay per-member fences).
+    // reads have dedicated lowerings that preserve absent metadata.
     if (isStdlibInterface("ErrnoException"))
         return { kind: "object", className: "%Error" };
     // spawn consumes a presence-sensitive option bag, including optional
@@ -1957,12 +1995,7 @@ function mapTypeInner(type, ctx) {
             ctx.isStdlibFile(d.getSourceFile()) &&
             isDeclaredInAmbientModule(d, "fs")))
         return DYN;
-    if ((psym?.name === "Worker" || psym?.name === "MessagePort") &&
-        checker
-            .declarationsOf(psym)
-            .some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
-            ctx.isStdlibFile(d.getSourceFile()) &&
-            isDeclaredInAmbientModule(d, "worker_threads")))
+    if (isWorkerHandleSymbol(psym, ctx))
         return DYN;
     // fs/promises.FileHandle: an owned descriptor object. Module provenance
     // distinguishes it from user interfaces with the same name; both the
@@ -2090,7 +2123,9 @@ function mapTypeInner(type, ctx) {
             .declarationsOf(psym)
             .some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(d.getSourceFile()) &&
-            isDeclaredInAmbientModule(d, "tty"))) ||
+            (isDeclaredInAmbientModule(d, "tty") ||
+                (isDeclaredInAmbientModule(d, "process") &&
+                    isDeclaredInAmbientNamespace(d, "NodeJS"))))) ||
         (psym?.name === "WritableStream" &&
             checker
                 .declarationsOf(psym)
@@ -2177,8 +2212,8 @@ function mapTypeInner(type, ctx) {
     // NodeJS.ErrnoException: @types/node's `interface ErrnoException extends
     // Error` (dns/fs callback error types). It IS an Error at runtime — map
     // it to the runtime %Error hierarchy like the lib Error interfaces
-    // above; the optional errno/code/path/syscall extras fence per member
-    // (the .stack stance). Provenance-checked like the rest.
+    // above; optional metadata uses the same checked property view.
+    // Provenance-checked like the rest.
     if (psym?.name === "ErrnoException" &&
         checker
             .declarationsOf(psym)
@@ -2309,6 +2344,17 @@ function mapTypeInner(type, ctx) {
     // Native collection iterators use checked runtime iterator objects.
     if (isStdlibInterface("MapIterator") || isStdlibInterface("SetIterator"))
         return DYN;
+    // Array iterators (`list.values()` and friends) are generators over the
+    // live array: each step reads the current length and element.
+    if (isStdlibInterface("ArrayIterator")) {
+        const arg = checker.getTypeArguments(widened)[0];
+        const yieldT = arg ? mapType(arg, ctx) : null;
+        if (!yieldT || yieldT.kind === "void" || isUnitType(yieldT))
+            return null;
+        if (!genResultRecord(yieldT, VOID, ctx.shapes, unions))
+            return null;
+        return { kind: "generator", yieldT, retT: VOID, nextT: UNDEFINED_T };
+    }
     // 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:
@@ -2329,7 +2375,10 @@ function mapTypeInner(type, ctx) {
     // branch of the result record has the same representation.
     if (isStdlibInterface("Generator") ||
         isStdlibInterface("AsyncGenerator") ||
-        isStdlibInterface("IterableIterator")) {
+        isStdlibInterface("IterableIterator") ||
+        // An Iterator<T> annotation holds a single-pass iterator object: a
+        // generator, or a native iterator adapted into one.
+        isStdlibInterface("Iterator")) {
         const args = checker.getTypeArguments(widened);
         const channels = genChannels(args[0], args[1], args[2], ctx);
         if (!channels)
@@ -2716,11 +2765,12 @@ function mapTypeInner(type, ctx) {
         // has no declaration): the dotDotDot check below can't see it, and a
         // fixed-arity func mapping would LIE about the value's calling
         // convention. Detected by the param-count mismatch against the
-        // signature's own declaration; unmappable like spelled rest.
+        // signature's own declaration, excluding an erased `this` parameter.
         {
             const sigDecl = checker.signatureDeclaration(sig);
             const declParams = sigDecl !== undefined && ts.isFunctionLike(sigDecl) ? sigDecl.parameters : undefined;
-            if (declParams !== undefined && declParams.length !== sig.getParameters().length) {
+            if (declParams !== undefined &&
+                runtimeParameterCount(declParams) !== sig.getParameters().length) {
                 return null;
             }
             // tsgo never SYNTHESIZES that rest param into the inferred signature
@@ -3678,7 +3728,7 @@ export function unitOnlyUnion(unions) {
  * answers undefined). ONE shape per channel pair — `g.next()`'s lowering,
  * `.return()`, `.throw()`, the for-of desugar, and mapType's
  * IteratorResult alias mapping all intern through here, so reads agree.
- * Null when the combined union would be illegal (a container arm beside
+ * Null when the combined union would be illegal (a promise arm beside
  * data arms, a regex/Date arm — kinds with no narrowing test here): such
  * generators stay unmapped. */
 export function genResultRecord(yieldT, retT, shapes, unions) {
@@ -3706,7 +3756,7 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
             return null;
         byKey.set(typeKey(UNDEFINED_T), UNDEFINED_T);
         const arms = [...byKey.values()];
-        // Containers keep the shared nullable-only rule. Generator function
+        // Promises keep the shared nullable-only rule. Generator function
         // payloads retain their existing unit-only boundary too.
         if (!unionContainerArmsOk(arms) ||
             arms.some((a) => a.kind === "func" && !arms.every((b) => b === a || isUnitType(b)))) {
@@ -3834,6 +3884,58 @@ 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) };
 }
+/** Optional standard error metadata refines an existing Error identity;
+ * it does not allocate a structural copy or extend its native layout. */
+function mapErrorMetadataIntersection(type, ctx) {
+    const parts = ts.constituentTypes(type);
+    // Do not map unrelated intersections speculatively: mapping recursive
+    // structural types can intern their representation before it is complete.
+    const hasError = parts.some((part) => {
+        const symbol = part.getSymbol();
+        return (symbol !== undefined &&
+            [
+                "Error",
+                "EvalError",
+                "RangeError",
+                "ReferenceError",
+                "SyntaxError",
+                "TypeError",
+                "URIError",
+                "AggregateError",
+            ].includes(symbol.name) &&
+            ctx.checker.declarationsOf(symbol).some((decl) => ctx.isStdlibFile(decl.getSourceFile())));
+    });
+    if (!hasError)
+        return null;
+    let error = null;
+    for (const part of parts) {
+        const mapped = mapType(part, ctx);
+        if (mapped?.kind === "object" && RUNTIME_ERROR_CLASSES.has(mapped.className)) {
+            if (error && !typeEquals(error, mapped))
+                return null;
+            error = mapped;
+            continue;
+        }
+        if (ctx.checker.getCallSignatures(part).length ||
+            ctx.checker.getConstructSignatures(part).length ||
+            ctx.checker.getIndexInfosOfType(part).length)
+            return null;
+        for (const property of ctx.checker.getPropertiesOfType(part)) {
+            const expected = property.name === "errno"
+                ? "f64"
+                : ["code", "syscall", "path", "dest"].includes(property.name)
+                    ? "string"
+                    : null;
+            if (!expected || !(property.flags & ts.SymbolFlags.Optional))
+                return null;
+            const field = mapType(ctx.checker.getTypeOfSymbol(property), ctx);
+            const arms = field?.kind === "union" ? ctx.unions.get(field.unionId)?.arms : field ? [field] : [];
+            if (!arms?.length || !arms.every((arm) => arm.kind === expected || arm.kind === "undefinedT"))
+                return null;
+        }
+    }
+    return error;
+}
 /** 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
@@ -4046,6 +4148,9 @@ function mapRecordType(widened, ctx) {
             inner.fields.every((field) => field.type.kind === "dyn") &&
             (inner.indexValue === undefined || inner.indexValue.kind === "dyn"))
             return DYN;
+        const refined = refinedConstituentShape(widened, inner, ctx);
+        if (refined !== null)
+            return { kind: "record", shapeId: refined };
         return {
             kind: "record",
             shapeId: shapes.intern(inner.fields, false, inner.indexValue, inner.declaredOrder),
@@ -4055,6 +4160,44 @@ function mapRecordType(widened, ctx) {
         shapes.inProgress.delete(widened);
     }
 }
+/** A refinement intersection (`Expr & { kind: "mul" }`, which the checker
+ * reduces to `Mul & { kind: "mul" }`) keeps the shape of the constituent it
+ * refines when the refinement changes no field's representation. Recursive
+ * declarations own distinct shape ids even when their layouts coincide
+ * (`Add` and `Mul` both `{ kind; left; right }`), and the structural key
+ * names only the first of them, so interning the intersection by structure
+ * could select a lookalike: a different arm of the very union the value is
+ * narrowed from. Constituents still being mapped are left alone, so this
+ * never mints a recursive placeholder. */
+function refinedConstituentShape(widened, parts, ctx) {
+    if (!widened.isIntersectionType())
+        return null;
+    const { checker, shapes } = ctx;
+    const names = checker.getPropertiesOfType(widened).map((prop) => prop.name);
+    let found = null;
+    for (const part of ts.constituentTypes(widened)) {
+        if ((part.flags & ts.TypeFlags.Object) === 0 || shapes.inProgress.has(part))
+            continue;
+        const own = new Set(checker.getPropertiesOfType(part).map((prop) => prop.name));
+        if (own.size !== names.length || !names.every((name) => own.has(name)))
+            continue;
+        const mapped = mapType(part, ctx);
+        if (mapped?.kind !== "record")
+            continue;
+        const shape = shapes.get(mapped.shapeId);
+        if (!shape ||
+            shape.tuple ||
+            shape.fields.length !== parts.fields.length ||
+            !shape.fields.every((field, i) => field.name === parts.fields[i].name && typeEquals(field.type, parts.fields[i].type)) ||
+            (shape.indexValue === undefined) !== (parts.indexValue === undefined) ||
+            (shape.indexValue !== undefined && !typeEquals(shape.indexValue, parts.indexValue)))
+            continue;
+        if (found !== null && found !== mapped.shapeId)
+            return null;
+        found = mapped.shapeId;
+    }
+    return found;
+}
 function mapRecordTypeInner(widened, ctx) {
     const { checker, shapes } = ctx;
     if (checker.getConstructSignatures(widened).length > 0)
@@ -4434,10 +4577,7 @@ function armHasUnionHome(arm, siblingCount) {
         case "generator":
         case "dyn":
             return false;
-        // Containers map only beside unit siblings; data siblings have no
-        // supported runtime narrowing test against them.
-        case "map":
-        case "set":
+        // Promise data siblings still lack a supported narrowing contract.
         case "promise":
             return siblingCount === 0;
         default:
@@ -4565,7 +4705,8 @@ export function describeComponentBlocker(widened, ctx) {
         const sigDecl = checker.signatureDeclaration(sig);
         if (sigDecl !== undefined &&
             ts.isFunctionLike(sigDecl) &&
-            (sigDecl.parameters.length !== sig.getParameters().length || bodyReadsArguments(sigDecl))) {
+            (runtimeParameterCount(sigDecl.parameters) !== sig.getParameters().length ||
+                bodyReadsArguments(sigDecl))) {
             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()) {