@scriptc/compiler 0.4.2 → 0.4.4

package/dist/frontend/type-mapper.js

@@ -3,8 +3,8 @@ import { keyedHelperName } from "./lowering/stable-names.js";
 import { mockCallRecordType, mockContextType } from "./mock-shapes.js";
 import * as ts from "./ts7/adapter.js";
 import { bodyReadsArguments } from "./arguments-usage.js";
-import { BYTES_ELEMENT_NAME, arrayOf, isDynTypedRefType, BOOL, bytesOf, canConvertToDyn, canDynCheckTo, CHILD_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, ZLIB_STREAM_MODES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, maybePromiseUnionArmsOk, unionContainerArmsOk, UNDEFINED_T, VOID, } from "../ir/ir.js";
-import { BIGINT_T } from "../ir/ir.js";
+import { BYTES_ELEMENT_NAME, arrayOf, isDynTypedRefType, BOOL, bytesOf, canConvertToDyn, canDynCheckTo, CHILD_T, CRYPTOHASH_T, CRYPTOHMAC_T, DATE_T, DYN, F64, funcOf, isSupportedArrayElem, isSupportedIndexValue, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, iterableArmsElem, isUnitType, mapOf, NULL_T, PROCSTREAM_T, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, ZLIB_STREAM_MODES, setOf, STRING, SYMBOL_T, typeEquals, typeKey, maybePromiseUnionArmsOk, unionContainerArmsOk, UNDEFINED_T, VOID, } from "../ir/ir.js";
+import { BIGINT_T, KEY_ORDER_FIELD } from "../ir/ir.js";
 import { literalValues } from "./literal-values.js";
 import { remapUnionDiscriminant } from "./union-discriminants.js";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
@@ -121,6 +121,7 @@ export const CRYPTO_KEY_OPTION_DYN_TYPES = new Set([
     "PrivateKeyInput",
     "PublicKeyInput",
     "RSAKeyPairKeyObjectOptions",
+    "X25519KeyPairOptions",
     "RSAKeyPairOptions",
     "SignKeyObjectInput",
     "SignPrivateKeyInput",
@@ -150,6 +151,9 @@ export const FETCH_AMBIENT_TYPES = [
     "ReadableStreamReadResult",
     "ReadableStreamReadValueResult",
     "ReadableStreamReadDoneResult",
+    "TransformStream",
+    "WritableStream",
+    "WritableStreamDefaultWriter",
     "Blob",
     "File",
     "BlobPropertyBag",
@@ -446,6 +450,20 @@ export class ShapeRegistry {
         const missing = extra.filter((name) => !order.includes(name));
         return missing.length === 0 ? order : [...order, ...missing];
     }
+    /** Gives a shape with orderVariants its KEY_ORDER_FIELD, in place,
+     * after the bodies lowered (key-order-witness.ts adds the field to each
+     * of the shape's literals). Allocation zeroes it, which every other
+     * construction keeps. */
+    addKeyOrderField(shapeId) {
+        const shape = this.byId.get(shapeId);
+        if (!shape || shape.fields.some((f) => f.name === KEY_ORDER_FIELD))
+            return;
+        shape.fields = [...shape.fields, { name: KEY_ORDER_FIELD, type: F64 }].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+        this.revision++;
+        const key = this.keyOf(shape.fields, false, shape.indexValue);
+        if (!this.byKey.has(key))
+            this.byKey.set(key, shapeId);
+    }
     /** Adds optional fields to an interned shape in place: members a type
      * assertion attaches to the shape's values (`r as R & { tag: string }`
      * followed by `view.tag = ...`; see assertion-members.ts). Every value
@@ -1067,8 +1085,16 @@ function genChannels(yieldTs, retTs, nextTs, ctx) {
     if (!nextT || nextT.kind === "void" || nextT.kind === "nullT")
         return null;
     const ownChannel = (t) => t.kind === "f64" || t.kind === "bool" || t.kind === "string";
+    // A record yield channel keeps its type beside a dyn return (an
+    // `IterableIterator<Row>`). A record return channel beside a dyn yield
+    // does not: the value a delegating `yield*` answers (Effect.gen's
+    // generators) is often an object whose methods a record would drop.
     const dynMix = (yieldT.kind === "dyn" && retT.kind !== "dyn" && retT.kind !== "void" && !ownChannel(retT)) ||
-        (retT.kind === "dyn" && yieldT.kind !== "dyn" && yieldT.kind !== "void" && !ownChannel(yieldT));
+        (retT.kind === "dyn" &&
+            yieldT.kind !== "dyn" &&
+            yieldT.kind !== "void" &&
+            !ownChannel(yieldT) &&
+            yieldT.kind !== "record");
     if (dynMix)
         return { yieldT: DYN, retT: DYN, nextT };
     return { yieldT, retT, nextT };
@@ -1489,9 +1515,15 @@ function mapTypeInner(type, ctx) {
     // TypeScript's intrinsic globalThis symbol has no declaration. A stored
     // reference needs native object identity, including var's undefined state.
     const intrinsic = type.getSymbol();
-    if (intrinsic !== undefined &&
-        ts.symbolName(intrinsic) === "globalThis" &&
-        intrinsic.declarations.length === 0)
+    const isIntrinsicGlobal = (symbol) => symbol !== undefined &&
+        ts.symbolName(symbol) === "globalThis" &&
+        symbol.declarations.length === 0;
+    if (isIntrinsicGlobal(intrinsic))
+        return DYN;
+    // `typeof globalThis & { key?: T }` (the global-singleton spelling) is the
+    // same global object with declared extra members.
+    if (type.isIntersectionType() &&
+        ts.constituentTypes(type).some((part) => isIntrinsicGlobal(part.getSymbol())))
         return DYN;
     if (ctx.jsDynamicDeclaration !== undefined && intrinsic !== undefined) {
         const objectLiteral = (intrinsic.flags & ts.SymbolFlags.ObjectLiteral) !== 0;
@@ -1994,6 +2026,23 @@ function mapTypeInner(type, ctx) {
             return arrayOf(unitOnlyUnion(unions));
         if (tupleShape?.elementFlags === undefined)
             return null;
+        // A leading-required tuple ending in a rest element whose positions
+        // all share one type (`[string, ...string[]]`, the non-empty list)
+        // is an array of that type: every read, write and method behaves as
+        // the array's, and tsc already proves the required positions exist.
+        const flags = tupleShape.elementFlags;
+        if (flags.length >= 2 &&
+            (flags[flags.length - 1] & ts.ElementFlags.Rest) !== 0 &&
+            flags.slice(0, -1).every((f) => (f & ts.ElementFlags.Required) !== 0)) {
+            const elems = args.map((a) => mapType(a, ctx));
+            const first = elems[0];
+            if (first &&
+                first.kind !== "void" &&
+                isSupportedArrayElem(first) &&
+                elems.every((e) => e !== null && typeEquals(e, first)))
+                return arrayOf(first);
+            return null;
+        }
         // Optional/rest elements have no fixed native tuple layout.
         if (tupleShape.elementFlags.some((f) => !(f & ts.ElementFlags.Required))) {
             return null;
@@ -2585,7 +2634,7 @@ function mapTypeInner(type, ctx) {
     }
     if (psym &&
         FETCH_AMBIENT_TYPES.includes(ts.symbolName(psym)) &&
-        !(ts.symbolName(psym) === "ReadableStream" &&
+        !((ts.symbolName(psym) === "ReadableStream" || ts.symbolName(psym) === "WritableStream") &&
             psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS"))) &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
@@ -2653,6 +2702,9 @@ function mapTypeInner(type, ctx) {
     // The runtime rejects reference kinds without a weak lifetime contract.
     if (isStdlibInterface("WeakMap") || isStdlibInterface("WeakSet"))
         return DYN;
+    // FinalizationRegistry is a native handle with register and unregister.
+    if (isStdlibInterface("FinalizationRegistry"))
+        return DYN;
     // Set<T>: Map's sibling — same provenance rule and key domain.
     // Anything else stays unmapped;
     // the `new Set` lowering names the offending element type specifically.
@@ -2669,10 +2721,9 @@ function mapTypeInner(type, ctx) {
     const collectionView = mapCollectionView(widened, ctx);
     if (collectionView)
         return collectionView;
-    // Date: a TimeClip'd epoch-millisecond scalar in the static runtime.
-    // This supports stored/passed values and the read-only getter slice;
-    // identity and mutation stay fenced because the scalar deliberately
-    // carries no object identity.
+    // Date: a refcounted object holding its TimeClip'd time value (ScrDate),
+    // shared with the checked-dynamic Date handle, so it keeps its identity
+    // through every slot and through `unknown`. Setters stay fenced.
     if (isStdlibInterface("Date"))
         return DATE_T;
     // RegExp: a reference to the lib RegExp interface — provenance, not the
@@ -3260,8 +3311,10 @@ function mapTypeInner(type, ctx) {
     // Mixed dyn/concrete value channels share checked storage, so either
     // branch of the result record has the same representation. A number,
     // boolean or string channel keeps its own type beside a dyn one (the
-    // `Generator<number>` defaults): its values ride OUT typed and box only
-    // when the result record is built.
+    // `Generator<number>` default), and so does a record yield channel beside
+    // a dyn return (`IterableIterator<Row>`): its values ride OUT typed and box
+    // only when the result record is built, so for-of and spread read them
+    // back unchecked.
     if (isStdlibInterface("Generator") ||
         isStdlibInterface("AsyncGenerator") ||
         isStdlibInterface("IterableIterator") ||
@@ -3285,6 +3338,14 @@ function mapTypeInner(type, ctx) {
             ...channels,
         };
     }
+    // Iterable<T>: the iterable union (iterableUnionType) — the source value
+    // itself in its own arm, so an array stays the same multi-pass object and
+    // a generator stays single-pass.
+    if (isStdlibInterface("Iterable")) {
+        const arg = checker.getTypeArguments(widened)[0];
+        const elem = arg ? mapType(arg, ctx) : null;
+        return elem ? iterableUnionType(elem, ctx.shapes, unions) : null;
+    }
     // IteratorResult<T, TReturn> — the checker's type of `g.next()` (an
     // alias for IteratorYieldResult<T> | IteratorReturnResult<TReturn>):
     // maps to the SAME interned record genResume answers, so `const r =
@@ -3402,6 +3463,13 @@ 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, false, undefined, order) };
     }
+    // crypto.getCipherInfo's result is Node's info object itself, read as a
+    // checked-dynamic value: Node leaves out the fields a cipher lacks,
+    // including the nid the declaration requires, so a record cannot hold
+    // every result.
+    if (isStdlibInterface("CipherInfo") &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientModule(d, "crypto")))
+        return DYN;
     // Filesystem options are data records. Keep their declared optional fields
     // instead of allowing arbitrary standard-library interfaces into records.
     if (((psym !== undefined && ts.symbolName(psym) === "FileReadOptions") ||
@@ -3889,6 +3957,10 @@ function mapTypeInner(type, ctx) {
             return hybrid;
     }
     const callSigs = checker.getCallSignatures(widened);
+    // AsyncLocalStorage.snapshot()'s generic runner is a dyn function value
+    // (als.snapshot), called through the dyn call path.
+    if (callSigs.length === 1 && isAsyncLocalStorageSnapshot(callSigs[0], ctx))
+        return DYN;
     if (callSigs.length === 1)
         return mapCallSignature(callSigs[0], ctx);
     // Records: object types whose members are all data properties (shorthand
@@ -4178,9 +4250,10 @@ function mapTypeInner(type, ctx) {
             }
             if (arms.some((a) => a.kind === "void" ||
                 a.kind === "union" ||
-                a.kind === "date" ||
                 a.kind === "dyn" ||
-                a.kind === "generator") ||
+                // A generator arm only comes from an Iterable<T> (an optional
+                // one keeps its unit arms beside the iterable union's).
+                (a.kind === "generator" && iterableArmsElem(arms) === null)) ||
                 !maybePromiseUnionOk(parts, arms, ctx)) {
                 return null;
             }
@@ -4210,6 +4283,24 @@ function mapTypeInner(type, ctx) {
 /** One non-overloaded call signature's func type (mapTypeInner's
  * single-signature rule; erasedOverloadMemberType maps each overload of a
  * member through it). */
+/** Whether `sig` is the function type AsyncLocalStorage.snapshot() returns:
+ * declared as that static method's return type in the async_hooks module
+ * of the standard library declarations. */
+function isAsyncLocalStorageSnapshot(sig, ctx) {
+    const decl = sig.declaration;
+    if (decl === undefined || !ts.isFunctionTypeNode(decl))
+        return false;
+    const method = decl.parent;
+    return (method !== undefined &&
+        ts.isMethodDeclaration(method) &&
+        ts.isIdentifier(method.name) &&
+        method.name.text === "snapshot" &&
+        method.parent !== undefined &&
+        ts.isClassDeclaration(method.parent) &&
+        method.parent.name?.text === "AsyncLocalStorage" &&
+        ctx.isStdlibFile(ts.getSourceFileOfNode(decl)) &&
+        isDeclaredInAmbientModule(decl, "async_hooks"));
+}
 function mapCallSignature(sig, ctx) {
     const { checker } = ctx;
     if (sig.getTypeParameters().length && ctx.erasingSignature !== sig)
@@ -4983,6 +5074,53 @@ function constAssertedEmptyArrayProp(p) {
         return false;
     return underConstAssertion(d);
 }
+/** A TypeScript property assignment `name: []` whose type is `never[]`. */
+function emptyNeverArrayProp(p, fieldTs, checker) {
+    const d = p.valueDeclaration;
+    if (d === undefined || !ts.isPropertyAssignment(d))
+        return false;
+    if (isJsSourceFile(ts.getSourceFileOfNode(d)))
+        return false;
+    if (!ts.isArrayLiteralExpression(d.initializer) || d.initializer.elements.nodes.length > 0)
+        return false;
+    return (checker.isArrayType(fieldTs) &&
+        (checker.getTypeArguments(fieldTs)[0].flags & ts.TypeFlags.Never) !== 0);
+}
+/** A JavaScript object literal's property typed `never[]` (`{ issues: [] }`).
+ * Nothing checks a JavaScript file's later writes, which can push any value
+ * onto it (`ctx.common.issues.push(issue)`), so it holds the checked-dynamic
+ * array rather than never's f64 element array. */
+function jsNeverArrayProp(p, fieldTs, checker) {
+    return (jsObjectLiteralProperty(p) &&
+        checker.isArrayType(fieldTs) &&
+        (checker.getTypeArguments(fieldTs)[0].flags & ts.TypeFlags.Never) !== 0);
+}
+/** A JavaScript object literal's property (`{ lastComponent: undefined }`,
+ * `{ user: null }`). Nothing checks a JavaScript file's later writes, which
+ * can store any value in it (`path.lastComponent = { ... }`), so a
+ * property whose only initializer is a unit holds the checked-dynamic value
+ * rather than the unit-only union. */
+function isUnitOnlyIr(t, ctx) {
+    if (t.kind !== "union")
+        return false;
+    const def = ctx.unions.get(t.unionId);
+    return def !== undefined && def.arms.every((arm) => isUnitType(arm));
+}
+/** A property a JavaScript object literal declares. The checker also adds
+ * each missing property, optional and `undefined`, to every literal of a
+ * union of literals (`{ _tag, value } | { _tag, error }` gains
+ * `error?: undefined` and `value?: undefined`); those keep their unit-only
+ * type, so a literal still converts to the one arm whose properties it
+ * has. */
+function jsObjectLiteralProperty(p) {
+    const d = p.valueDeclaration;
+    // `__proto__: null` sets the literal's prototype; it declares no property.
+    return (d !== undefined &&
+        (ts.isPropertyAssignment(d) || ts.isShorthandPropertyAssignment(d)) &&
+        ts.symbolName(p) !== "__proto__" &&
+        (p.flags & ts.SymbolFlags.Optional) === 0 &&
+        isJsSourceFile(ts.getSourceFileOfNode(d)));
+}
 function mapGenericAwaitedAlias(type, ctx) {
     const { resolveTypeParam } = ctx;
     if (!resolveTypeParam)
@@ -5545,6 +5683,40 @@ export function unitOnlyUnion(unions) {
     arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
     return { kind: "union", unionId: unions.intern(arms) };
 }
+/** `Iterable<T>`: a union whose arms are the sources that keep their own
+ * representation — `T[]`, a `Set<T>`, a `Map<K, V>` (T the `[K, V]`
+ * tuple), a string (T string) — and a generator over T, which also holds
+ * every other iterator (Map/Set and array iterators adapt into one). The
+ * generator arm marks the union as iterable (iterableArmsElem): no other
+ * union has one. Null when T has no array or generator form. */
+export function iterableUnionType(elem, shapes, unions) {
+    if (elem.kind === "void" || elem.kind === "generator" || !isSupportedArrayElem(elem))
+        return null;
+    if (!genResultRecord(elem, VOID, shapes, unions))
+        return null;
+    const arms = [
+        { kind: "array", elem },
+        { kind: "generator", yieldT: elem, retT: VOID, nextT: UNDEFINED_T },
+    ];
+    const elemArms = elem.kind === "union" ? unions.get(elem.unionId)?.arms : undefined;
+    if (isSupportedSetElem(elem, elemArms))
+        arms.push({ kind: "set", elem });
+    if (elem.kind === "string")
+        arms.push(STRING);
+    if (elem.kind === "record") {
+        const shape = shapes.get(elem.shapeId);
+        const [k, v] = shape?.fields ?? [];
+        if (shape?.tuple &&
+            shape.fields.length === 2 &&
+            k?.name === "0" &&
+            v?.name === "1" &&
+            isSupportedMapKey(k.type, k.type.kind === "union" ? unions.get(k.type.unionId)?.arms : undefined) &&
+            isSupportedMapValue(v.type))
+            arms.push({ kind: "map", key: k.type, value: v.type });
+    }
+    arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
+    return { kind: "union", unionId: unions.intern(arms) };
+}
 /** The IteratorResult record of a generator's value channels: `{ done:
  * boolean, value: V }` where V is dyn (an any/unknown channel) or the
  * canonical union of the yield arms, the return arms (when the return
@@ -5570,7 +5742,7 @@ export function genResultRecord(yieldT, retT, shapes, unions) {
                     byKey.set(typeKey(a), a);
                 return true;
             }
-            if (t.kind === "regex" || t.kind === "date" || t.kind === "generator") {
+            if (t.kind === "regex" || t.kind === "generator") {
                 return false; // no legal union arm exists for these kinds
             }
             byKey.set(typeKey(t), t);
@@ -5645,16 +5817,16 @@ export function withUnitArm(t, kind, unions) {
         const def = unions.get(t.unionId);
         if (!def)
             return null;
-        if (def.arms.some((a) => a.kind === "date"))
-            return null;
         if (def.arms.some((a) => a.kind === kind))
             return t;
         const arms = [...def.arms, unit];
+        // Date and Promise arms beside other data arms have no union home.
+        if (!unionContainerArmsOk(arms))
+            return null;
         arms.sort((a, b) => (typeKey(a) < typeKey(b) ? -1 : 1));
         return { kind: "union", unionId: unions.transform(def, arms) };
     }
     if (t.kind === "void" ||
-        t.kind === "date" ||
         t.kind === "dyn" ||
         // A bare unit field type cannot occur (units live only inside unions),
         // but guard against constructing a single-arm union from one.
@@ -6667,6 +6839,24 @@ function wideningAddedProperties(type, props, ctx) {
     }
     return added;
 }
+/** Whether `type` is an interface one of whose `extends` clauses names a
+ * type the checker answers `any` (or an error type) for. */
+function interfaceExtendsAny(type, checker) {
+    const symbol = type.getSymbol();
+    if (symbol === undefined || (symbol.flags & ts.SymbolFlags.Interface) === 0)
+        return false;
+    for (const decl of symbol.declarations) {
+        if (!ts.isInterfaceDeclaration(decl))
+            continue;
+        for (const clause of decl.heritageClauses?.nodes ?? []) {
+            for (const base of clause.types.nodes) {
+                if ((checker.getTypeAtLocation(base).flags & ts.TypeFlags.Any) !== 0)
+                    return true;
+            }
+        }
+    }
+    return false;
+}
 function mapRecordTypeInner(widened, ctx) {
     const { checker, shapes } = ctx;
     if (checker.getConstructSignatures(widened).length > 0)
@@ -6682,6 +6872,14 @@ function mapRecordTypeInner(widened, ctx) {
     const widenedSym = widened.getSymbol();
     if (widenedSym !== undefined && (widenedSym.flags & ts.SymbolFlags.Enum) !== 0)
         return null;
+    // An interface extending a type the checker answers `any` for (in the
+    // compiled world, a package type computed from members only its .d.ts
+    // declares, such as `interface P extends z.infer<typeof S>`) has members
+    // the checker cannot list: its own declared fields are not the whole
+    // object. The value is checked-dynamic, never a record of the declared
+    // fields alone.
+    if (interfaceExtendsAny(widened, checker))
+        return DYN;
     // An index signature maps to a hybrid shape: declared fields keep
     // struct slots, undeclared keys ride the shape's overflow map, valued
     // uniformly by the signature's value type (`unknown` → dyn — a model-pricing table's
@@ -6951,6 +7149,14 @@ function mapRecordTypeInner(widened, ctx) {
                 constAssertedEmptyArrayProp(p)) {
                 pt = arrayOf(unitOnlyUnion(ctx.unions));
             }
+            // A TypeScript property initialized with an empty literal and typed
+            // `never[]` (`const out = { files: [] }`) holds no element, so it maps
+            // like the empty tuple: the unit-only element array, which a
+            // destination's typed array field (`files: string[]`) receives through
+            // the checked empty-array lift. never's f64 element would make it a
+            // `number[]` field.
+            if (pt?.kind === "array" && emptyNeverArrayProp(p, fieldTs, checker))
+                pt = arrayOf(unitOnlyUnion(ctx.unions));
             if (pt === null && (fieldTs.flags & ts.TypeFlags.Any) !== 0)
                 pt = DYN;
             // An `any[]` field (`list: any[]` in an SDK's message type, also
@@ -6970,6 +7176,10 @@ function mapRecordTypeInner(widened, ctx) {
             // omits the undefined arm exactly like an omitted optional.
             if (pt?.kind === "void" && isUnitOnlyTsType(fieldTs, ctx.resolveTypeParam))
                 pt = unitOnlyUnion(ctx.unions);
+            if (pt !== null && isUnitOnlyIr(pt, ctx) && jsObjectLiteralProperty(p))
+                pt = DYN;
+            if (pt?.kind === "array" && jsNeverArrayProp(p, fieldTs, checker))
+                pt = DYN;
             // dyn FIELDS map now (`{ v: unknown }`, `[string, unknown]` tuples):
             // the slot carries a dyn value exactly like an `unknown`-valued
             // overflow entry — same RC adapters, same dynFrom conversion on the
@@ -7132,7 +7342,6 @@ function armHasUnionHome(arm) {
         case "void":
         case "union":
         case "regex":
-        case "date":
         case "generator":
         case "dyn":
             return false;