@scriptc/compiler 0.4.1 → 0.4.2

package/dist/frontend/type-mapper.js

@@ -1,4 +1,5 @@
 import { InternalCompilerError } from "../errors.js";
+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";
@@ -7,6 +8,7 @@ import { BIGINT_T } from "../ir/ir.js";
 import { literalValues } from "./literal-values.js";
 import { remapUnionDiscriminant } from "./union-discriminants.js";
 import { isJsSourceFile, isNodeTypesPath } from "./program.js";
+import { isProvenanceSourceFile } from "./provenance-registry.js";
 import { functionCanReturnUndefined } from "./function-completion.js";
 import { accessorSlotProp, recordTextCodecClass } from "../ir/ir.js";
 // typeKey moved to ir/ir.ts (the backend needs it too, for per-type
@@ -85,6 +87,46 @@ export const WEBCRYPTO_DYN_TYPES = new Set([
     "KeyAlgorithm",
     "HmacImportParams",
     "HmacKeyAlgorithm",
+    "CryptoKeyPair",
+    "EcKeyAlgorithm",
+    "RsaHashedKeyAlgorithm",
+    "EcKeyGenParams",
+    "EcKeyImportParams",
+    "EcdsaParams",
+    "RsaHashedKeyGenParams",
+    "RsaHashedImportParams",
+    "RsaPssParams",
+    "HmacKeyGenParams",
+    "AesKeyGenParams",
+    "AesKeyAlgorithm",
+    "JsonWebKey",
+    "AesGcmParams",
+    "AesCbcParams",
+    "AesCtrParams",
+    "Pbkdf2Params",
+    "HkdfParams",
+    "AesDerivedKeyParams",
+]);
+/** node:crypto's key and signature option interfaces: the key functions,
+ * KeyObject.export and sign/verify take them as checked-dynamic arguments
+ * (scr_lib.c, scr_pki.c). */
+export const CRYPTO_KEY_OPTION_DYN_TYPES = new Set([
+    "AsymmetricKeyExportOptions",
+    "ECKeyPairKeyObjectOptions",
+    "ECKeyPairOptions",
+    "ED25519KeyPairOptions",
+    "JsonWebKeyInput",
+    "JwkKeyExportOptions",
+    "KeyExportOptions",
+    "PrivateKeyInput",
+    "PublicKeyInput",
+    "RSAKeyPairKeyObjectOptions",
+    "RSAKeyPairOptions",
+    "SignKeyObjectInput",
+    "SignPrivateKeyInput",
+    "SigningOptions",
+    "VerifyKeyObjectInput",
+    "VerifyPublicKeyInput",
 ]);
 export const FETCH_AMBIENT_TYPES = [
     "Response",
@@ -179,6 +221,8 @@ function comparePriority(left, right) {
 export class ShapeRegistry {
     /** Existing layouts change only when a recursive placeholder closes. */
     revision = 0;
+    /** Each shape id with a second hash of its key (keyedHelperName). */
+    keyedNameKeys = new Map();
     byKey = new Map();
     byId = new Map();
     /** Historical emit-order rank of the declaration-order metadata each
@@ -194,7 +238,7 @@ export class ShapeRegistry {
      * writer after all priority candidates have closed. */
     derivedDeclaredOrderFinalizers = [];
     currentDeclaredOrderPriority = [0, 0];
-    /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */
+    /** All interned shapes in first-seen order. */
     shapes = [];
     /** ts.Types currently being mapped — a BACK-REFERENCE to one of these is
      * the recursive knot (`interface TreeNode { children: TreeNode[] }`):
@@ -299,11 +343,12 @@ export class ShapeRegistry {
     }
     /** The shape id a back-reference to an in-progress type resolves to:
      * reuses the type's persistent recursive id or mints a PLACEHOLDER
-     * entry (empty fields) the outer frame finalizes. */
-    recursiveRef(t) {
+     * entry (empty fields) the outer frame finalizes. `describe` names a new
+     * placeholder (checkerTypeDescription). */
+    recursiveRef(t, describe) {
         let id = this.recIds.get(t);
         if (id === undefined) {
-            id = `r${this.shapes.length}`;
+            id = recursivePlaceholderName(this, "r", describe(), (name) => this.byId.has(name));
             const shape = { id, fields: [] };
             this.byId.set(id, shape);
             this.shapes.push(shape);
@@ -358,7 +403,7 @@ export class ShapeRegistry {
         const key = this.keyOf(fields, tuple, indexValue);
         let id = this.byKey.get(key);
         if (id === undefined) {
-            id = `r${this.shapes.length}`;
+            id = keyedHelperName(this, "r", key, "");
             const shape = {
                 id,
                 fields,
@@ -434,6 +479,44 @@ export class ShapeRegistry {
             this.byKey.set(key, shapeId);
     }
 }
+/** The id of a recursive placeholder described by `description`. Two
+ * different types can still share a description (checkerTypeDescription stops
+ * after a few levels of type arguments); the later one takes the first free
+ * name with a numbered suffix. */
+function recursivePlaceholderName(owner, prefix, description, taken) {
+    let name = keyedHelperName(owner, prefix, `recursive:${description}`, "");
+    for (let n = 1; taken(name); n++)
+        name = keyedHelperName(owner, prefix, `recursive:${description}#${n}`, "");
+    return name;
+}
+/** How many levels of type arguments checkerTypeDescription describes. */
+const RECURSIVE_NAME_DEPTH = 3;
+/** A checker type's description for names that must not depend on checker
+ * type ids (a recursive placeholder, a generic class instance keyed by a
+ * literal): its printed form, the structural position of its first
+ * declaration, and the same for its type arguments (two instantiations
+ * print the same when their type arguments are type parameters or classes
+ * of the same name from different declarations). */
+export function checkerTypeDescription(t, ctx, depth = 0) {
+    const symbol = t.getAliasSymbol() ?? t.getSymbol();
+    const declaration = symbol?.declarations[0];
+    const where = declaration
+        ? (ctx.positionOf?.(declaration) ??
+            `${ts.getSourceFileOfNode(declaration).fileName}:${declaration.pos}`)
+        : "";
+    let description = `${ctx.checker.typeToString(t)}@${where}`;
+    if (depth < RECURSIVE_NAME_DEPTH) {
+        const aliasArguments = t.getAliasSymbol() !== undefined ? (t.getAliasTypeArguments() ?? []) : [];
+        const typeArguments = aliasArguments.length > 0
+            ? aliasArguments
+            : t.isTypeReference()
+                ? ctx.checker.getTypeArguments(t)
+                : [];
+        if (typeArguments.length > 0)
+            description += `<${typeArguments.map((arg) => checkerTypeDescription(arg, ctx, depth + 1)).join(",")}>`;
+    }
+    return description;
+}
 /** The frontend's union interner — mirrors ShapeRegistry. A union's
  * canonical identity includes its typeKey-sorted arms and literal
  * discriminator contract. An arm's index in that list IS its runtime tag.
@@ -441,10 +524,12 @@ export class ShapeRegistry {
 export class UnionRegistry {
     /** Existing arm/discriminator contracts change when a placeholder closes. */
     revision = 0;
+    /** Each union id with a second hash of its key (keyedHelperName). */
+    keyedNameKeys = new Map();
     byKey = new Map();
     byId = new Map();
     armTags = new Map();
-    /** All interned unions in first-seen (`u0`, `u1`, ...) order. */
+    /** All interned unions in first-seen order. */
     unions = [];
     /** ts.Types currently being mapped — a back-reference to one is the
      * recursive knot passing through a union (`type Tree = Leaf | Branch`
@@ -459,11 +544,12 @@ export class UnionRegistry {
     pendingRec = new Set();
     /** The union id a back-reference to an in-progress union resolves to:
      * reuses the type's persistent recursive id or mints a PLACEHOLDER
-     * entry (empty arms) the outer frame finalizes. */
-    recursiveRef(t) {
+     * entry (empty arms) the outer frame finalizes. `describe` names a new
+     * placeholder (checkerTypeDescription). */
+    recursiveRef(t, describe) {
         let id = this.recIds.get(t);
         if (id === undefined) {
-            id = `u${this.unions.length}`;
+            id = recursivePlaceholderName(this, "u", describe(), (name) => this.byId.has(name));
             const def = { id, arms: [] };
             this.byId.set(id, def);
             this.unions.push(def);
@@ -509,7 +595,7 @@ export class UnionRegistry {
         const key = JSON.stringify([arms.map(typeKey), discriminant]);
         let id = this.byKey.get(key);
         if (id === undefined) {
-            id = `u${this.unions.length}`;
+            id = keyedHelperName(this, "u", key, "");
             const def = { id, arms, ...(discriminant ? { discriminant } : {}) };
             this.byKey.set(key, id);
             this.byId.set(id, def);
@@ -1325,10 +1411,18 @@ export function mapType(type, ctx) {
         if (flags & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral))
             return BOOL;
     }
+    const localValue = ctx.localClassValue?.(type);
+    if (localValue) {
+        contextResolutions++;
+        return localValue;
+    }
     const topLevel = mapTypeDepth === 0;
     const typeId = type.id;
     const memoizable = typeId !== undefined && (ctx.canMemoizeType?.() ?? true);
-    const memoKey = memoizable ? `${0}:${typeId}` : null;
+    // An empty literal's type maps to the empty record as an unreduced union's
+    // arm (emptyLiteralArm) and to the checked-dynamic value elsewhere: the two
+    // answers keep separate memo entries.
+    const memoKey = memoizable ? `${ctx.emptyLiteralArm ? 1 : 0}:${typeId}` : null;
     if (memoKey !== null) {
         const memo = ctx.typeMemo?.get(memoKey);
         if (memo !== undefined)
@@ -2119,6 +2213,25 @@ function mapTypeInner(type, ctx) {
                 return { kind: "classval", className: inst.className };
             }
         }
+        // A constructable declared in the program whose instances are not one
+        // program class's (`new () => unknown`, `abstract new () => S` over a
+        // record, a type that also names static members such as `{ readonly
+        // schema: unknown; new (): unknown }`, construct overloads): the class
+        // value rides the checked-dynamic tree, as an `unknown` slot already
+        // holds one. `new` through it and static reads dispatch at run time,
+        // and the constructed value checks into the signature's instance type.
+        // Lib and package constructables keep their fences, and so do those of
+        // fetched provenance sources (third-party code under its own policies:
+        // an unused `@__PURE__` const typed `{ new (): any }` elides there).
+        if (ctorSigs.length > 0 &&
+            checker.getCallSignatures(widened).length === 0 &&
+            (widened.getSymbol()?.declarations.length ?? 0) > 0 &&
+            widened.getSymbol().declarations.every((d) => {
+                const sf = ts.getSourceFileOfNode(d);
+                return ctx.isProgramFile(sf) && !isProvenanceSourceFile(sf.fileName);
+            })) {
+            return DYN;
+        }
     }
     // Map<K, V>: a reference to the standard library's Map interface —
     // provenance, not the name (a user's own `interface Map` maps as a record
@@ -2441,15 +2554,35 @@ function mapTypeInner(type, ctx) {
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
-    // node:crypto's KeyObject: secret keys are native handles (scr_lib.c)
-    // whose getters and methods dispatch through the handle. The JsonWebKey
-    // that export() returns is a plain checked-dynamic object.
+    // node:crypto's KeyObject: secret keys (scr_lib.c) and private and
+    // public keys (scr_pki.c) are native handles whose getters and methods
+    // dispatch through the handle. The JsonWebKey that export() returns is a
+    // plain checked-dynamic object.
     if (((psym !== undefined && ts.symbolName(psym) === "KeyObject") ||
         (psym !== undefined && ts.symbolName(psym) === "JsonWebKey")) &&
         psym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isInterfaceDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
+    // node:crypto's key and signature options are plain checked-dynamic
+    // objects, so a value asserted to one (`opts as
+    // crypto.AsymmetricKeyExportOptions<"pem">`) reaches the call unchanged.
+    if (psym !== undefined &&
+        CRYPTO_KEY_OPTION_DYN_TYPES.has(ts.symbolName(psym)) &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "crypto"))) {
+        return DYN;
+    }
+    // node:crypto's Sign and Verify (createSign/createVerify): native
+    // handles over the digest state (scr_pki.c).
+    if (psym !== undefined &&
+        (ts.symbolName(psym) === "Sign" || ts.symbolName(psym) === "Verify") &&
+        psym.declarations.some((d) => ts.isClassDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "crypto"))) {
+        return DYN;
+    }
     if (psym &&
         FETCH_AMBIENT_TYPES.includes(ts.symbolName(psym)) &&
         !(ts.symbolName(psym) === "ReadableStream" &&
@@ -2487,6 +2620,18 @@ function mapTypeInner(type, ctx) {
         psym.declarations.some((d) => ts.isClassDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return DYN;
     }
+    // node:crypto DiffieHellman values, and @types/node's DiffieHellmanGroup
+    // alias over them, are native handles carried by the checked-dynamic
+    // representation; lowerDiffieHellmanCall dispatches their methods.
+    {
+        const dhSym = widened.getAliasSymbol() ?? psym;
+        if (dhSym !== undefined &&
+            (ts.symbolName(dhSym) === "DiffieHellman" || ts.symbolName(dhSym) === "DiffieHellmanGroup") &&
+            dhSym.declarations.some((d) => (ts.isClassDeclaration(d) || ts.isTypeAliasDeclaration(d)) &&
+                ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+            return DYN;
+        }
+    }
     // ReadonlyMap/ReadonlySet are the SAME runtime values as Map/Set — the
     // readonly-ness is a checker-only view (no mutating members on the
     // interface), so both map to the identical IR kinds and the read-side
@@ -3466,6 +3611,32 @@ function mapTypeInner(type, ctx) {
             };
         }
     }
+    // crypto.generateKeyPairSync's results: KeyPairKeyObjectResult and
+    // KeyPairSyncResult<T1, T2> as { publicKey, privateKey } records over the
+    // mapped property types (KeyObjects, PEM strings or DER Buffers), in
+    // Node's key order.
+    if (psym !== undefined &&
+        (ts.symbolName(psym) === "KeyPairKeyObjectResult" ||
+            ts.symbolName(psym) === "KeyPairSyncResult") &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) &&
+            ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
+            isDeclaredInAmbientModule(d, "crypto"))) {
+        const field = (name) => {
+            const prop = ctx.checker.getPropertyOfType(type, name);
+            return prop ? mapType(ctx.checker.getTypeOfSymbol(prop), ctx) : null;
+        };
+        const publicKey = field("publicKey");
+        const privateKey = field("privateKey");
+        if (!publicKey || !privateKey)
+            return null;
+        return {
+            kind: "record",
+            shapeId: ctx.shapes.intern([
+                { name: "privateKey", type: privateKey },
+                { name: "publicKey", type: publicKey },
+            ], false, undefined, ["publicKey", "privateKey"]),
+        };
+    }
     // crypto.X509Certificate — the Dirent-style data record: THREE visible
     // fields (fingerprint and the validFrom/validTo validity window, all
     // computed at construction by the new-expression lowering). Module-
@@ -3872,7 +4043,10 @@ function mapTypeInner(type, ctx) {
         if (knownRecursive !== undefined)
             return { kind: "union", unionId: knownRecursive };
         if (unions.inProgress.has(widened)) {
-            return { kind: "union", unionId: unions.recursiveRef(widened) };
+            return {
+                kind: "union",
+                unionId: unions.recursiveRef(widened, () => checkerTypeDescription(widened, ctx)),
+            };
         }
         unions.inProgress.add(widened);
         const sensitivityAtEntry = contextResolutions;
@@ -3896,6 +4070,14 @@ function mapTypeInner(type, ctx) {
                     (part.getSymbol()?.declarations.some((d) => ctx.isStdlibFile(d.getSourceFile())) ?? false));
             };
             const hasArrayPart = parts.some((part) => checker.isArrayType(part) || matchArray(part));
+            // Subtype reduction removes every arm assignable to `{}`, so a union
+            // that keeps another non-nullish arm beside an empty literal's `{}`
+            // was not reduced: that `{}` arm holds only the literal's objects.
+            const nullish = ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Void;
+            const literalEmptyArms = parts.some((part) => isEmptyObjectLiteralType(part, ctx)) &&
+                parts.some((part) => (part.flags & nullish) === 0 &&
+                    !checker.isNeverType(part) &&
+                    !isEmptyObjectLiteralType(part, ctx));
             for (const part of parts) {
                 if (hasArrayPart && emptyTuple(part))
                     continue;
@@ -3916,7 +4098,19 @@ function mapTypeInner(type, ctx) {
                     byKey.set(typeKey(NULL_T), NULL_T);
                     continue;
                 }
-                const mapped = mapType(part, ctx);
+                let mapped;
+                if (literalEmptyArms && isEmptyObjectLiteralType(part, ctx)) {
+                    ctx.emptyLiteralArm = true;
+                    try {
+                        mapped = mapType(part, ctx);
+                    }
+                    finally {
+                        ctx.emptyLiteralArm = false;
+                    }
+                }
+                else {
+                    mapped = mapType(part, ctx);
+                }
                 if (!mapped) {
                     return null;
                 }
@@ -5050,7 +5244,8 @@ function evalMappedTemplate(type, keys, aliases, ctx) {
         const checked = evalMappedTemplate(checkType, keys, scope, ctx);
         if (!checked)
             return null;
-        const inferred = matchInferReference(checked, extendsType, ctx);
+        const inferred = primitiveExtendsCheck(checked, extendsType, ctx) ??
+            matchInferReference(checked, extendsType, ctx);
         if (inferred === undefined)
             return null;
         const branch = inferred ? type.getTrueType() : type.getFalseType();
@@ -5059,6 +5254,24 @@ function evalMappedTemplate(type, keys, aliases, ctx) {
     }
     return mentionsMappedParams(type, keys, aliases) ? null : type;
 }
+/** `checked extends X` where X is a primitive or literal type, or a union of
+ * them (`K extends "required" ? ...`), and `checked` is one such type:
+ * X has no infer positions, so assignability decides the branch (an empty
+ * binding map for the true branch). A union `checked` distributes and stays
+ * undecided here (undefined), as do other shapes. */
+function primitiveExtendsCheck(checked, extendsType, ctx) {
+    const primitive = ts.TypeFlags.StringLike |
+        ts.TypeFlags.NumberLike |
+        ts.TypeFlags.BooleanLike |
+        ts.TypeFlags.BigIntLike |
+        ts.TypeFlags.Null |
+        ts.TypeFlags.Undefined;
+    const isPrimitive = (t) => !t.isUnionType() && (t.flags & primitive) !== 0 && (t.flags & ts.TypeFlags.TypeParameter) === 0;
+    const extendsParts = extendsType.isUnionType() ? ts.constituentTypes(extendsType) : [extendsType];
+    if (!isPrimitive(checked) || !extendsParts.every(isPrimitive))
+        return undefined;
+    return ctx.checker.isTypeAssignableTo(checked, extendsType) ? new Map() : false;
+}
 /** `checked extends G<..., infer T, ...>`: the infer bindings when
  * `checked` is a reference to the same generic `G` (its arguments bind the
  * infer positions; other positions must be the same types), false when it
@@ -6067,7 +6280,10 @@ function mapRecordType(widened, ctx) {
     // frame completes (finalizeRecursive below). Backends represent records
     // as heap references, so the self-reference is an ordinary pointer.
     if (shapes.inProgress.has(widened)) {
-        return { kind: "record", shapeId: shapes.recursiveRef(widened) };
+        return {
+            kind: "record",
+            shapeId: shapes.recursiveRef(widened, () => checkerTypeDescription(widened, ctx)),
+        };
     }
     shapes.inProgress.add(widened);
     const sensitivityAtEntry = contextResolutions;
@@ -6607,24 +6823,28 @@ function mapRecordTypeInner(widened, ctx) {
         // has zero declared members — the signature is the shape.
         if (computed && props.length === 0 && !indexValue)
             return null;
-        // A DECLARED empty object type — `{}` (spelled or the checker's shared
-        // intrinsic), `interface Empty {}` — is tsc's TOP type over non-nullish
-        // values: every number, string, record, array, function, or class
-        // instance is assignable into the slot, so the exact-record stance
-        // cannot hold it. It lowers like `unknown` (the dyn), the same rule
-        // as `object` and the lib's `Object`: assignments convert at the site
-        // (sources outside the checked-dynamic tree fence there, exactly as unknown does), reads
-        // narrow back out through the same checked casts. The type INFERRED
-        // from an empty object literal (`const o = {}`) stays the empty record
-        // — it describes a value the program built, not an annotation that
-        // admits everything — and computed empties (`Partial<T>` in a generic
-        // body) returned null above. Empty shapes WITH an index signature
-        // (`Record<string, T>`) are not empty: the signature is the shape.
+        // An empty object type — `{}` (spelled, the checker's shared
+        // intrinsic, or inferred from an empty object literal), `interface
+        // Empty {}` — is tsc's TOP type over non-nullish values: every number,
+        // string, record, array, function, or class instance is assignable
+        // into the slot, so the exact-record stance cannot hold it. It lowers
+        // like `unknown` (the dyn), the same rule as `object` and the lib's
+        // `Object`: assignments convert at the site (sources outside the
+        // checked-dynamic tree fence there, exactly as unknown does), reads
+        // narrow back out through the same checked casts. A literal's inferred
+        // `{}` is no exception: union subtype reduction folds primitives into
+        // it (`["12", {}]` is `{}[]`, `flag ? "x" : {}` is `{}`), and `let o =
+        // {}` admits `o = "x"`. As an arm beside another non-nullish arm (the
+        // union was not reduced, `string | {} | DataView`) it holds only the
+        // literal's objects and stays the empty record (emptyLiteralArm).
+        // Computed empties (`Partial<T>` in a generic body) returned null
+        // above. Empty shapes WITH an index signature (`Record<string, T>`) are
+        // not empty: the signature is the shape.
         if (props.length === 0 &&
             indexValue === undefined &&
             checker.getCallSignatures(widened).length === 0 &&
             checker.getConstructSignatures(widened).length === 0 &&
-            !(anonSym !== undefined && anonSym.declarations.some((d) => ts.isObjectLiteralExpression(d)))) {
+            !(ctx.emptyLiteralArm && isEmptyObjectLiteralType(widened, ctx))) {
             return DYN;
         }
         const fields = [];
@@ -7225,4 +7445,17 @@ function innerBlockedMember(t, ctx, seen) {
     }
     return here;
 }
+/** The type tsc infers from an empty object literal (`{}` written as a
+ * value): no members, index signatures or signatures, declared by an object
+ * literal expression. */
+function isEmptyObjectLiteralType(type, ctx) {
+    const { checker } = ctx;
+    const symbol = type.getSymbol();
+    return (symbol !== undefined &&
+        symbol.declarations.some((d) => ts.isObjectLiteralExpression(d)) &&
+        checker.getPropertiesOfType(type).length === 0 &&
+        checker.getIndexInfosOfType(type).length === 0 &&
+        checker.getCallSignatures(type).length === 0 &&
+        checker.getConstructSignatures(type).length === 0);
+}
 //# sourceMappingURL=type-mapper.js.map