@scriptc/compiler 0.4.4 → 0.4.5

package/dist/frontend/type-mapper.js

@@ -107,9 +107,10 @@ export const WEBCRYPTO_DYN_TYPES = new Set([
     "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). */
+/** node:crypto's key, signature and X509Certificate check option
+ * interfaces: the key functions, KeyObject.export, sign/verify and the
+ * X509Certificate checks take them as checked-dynamic arguments
+ * (scr_lib.c, scr_pki.c, scr_x509.c). */
 export const CRYPTO_KEY_OPTION_DYN_TYPES = new Set([
     "AsymmetricKeyExportOptions",
     "ECKeyPairKeyObjectOptions",
@@ -128,6 +129,7 @@ export const CRYPTO_KEY_OPTION_DYN_TYPES = new Set([
     "SigningOptions",
     "VerifyKeyObjectInput",
     "VerifyPublicKeyInput",
+    "X509CheckOptions",
 ]);
 export const FETCH_AMBIENT_TYPES = [
     "Response",
@@ -1120,16 +1122,18 @@ let mapTypeDepth = 0;
  * stay fenced instead of interning a per-context-wrong shape). */
 let contextResolutions = 0;
 /** node:url's legacy record interfaces: url.parse()'s Url instance (and
- * its two query-typed refinements), url.format()'s UrlObject input, and the
- * URL form's URLFormatOptions. The values are checked-dynamic objects —
- * Node's Url instance carries its class name and null fields, and format()
- * reads any object's fields with JS truthiness. */
+ * its two query-typed refinements), url.format()'s UrlObject input, the
+ * URL form's URLFormatOptions, and urlToHttpOptions's result. The values
+ * are checked-dynamic objects — Node's Url instance carries its class name
+ * and null fields, format() reads any object's fields with JS truthiness,
+ * and urlToHttpOptions answers a null-prototype object. */
 const LEGACY_URL_TYPES = new Set([
     "Url",
     "UrlObject",
     "UrlWithParsedQuery",
     "UrlWithStringQuery",
     "URLFormatOptions",
+    "UrlHttpOptions",
 ]);
 export function isLegacyUrlType(type, ctx) {
     const symbol = type.getAliasSymbol() ?? type.getSymbol();
@@ -1394,9 +1398,16 @@ export function mapAsyncGeneratorAnnotation(type, ctx) {
         return null;
     return { kind: "generator", async: true, ...channels };
 }
-/** The native fetch handles (Headers, Request, Response), optionally in
- * arrays or with null/undefined: checked-dynamic handles wherever they are
- * stored, like the worker handles above. */
+const FETCH_HANDLE_NAMES = new Set([
+    "Headers",
+    "Request",
+    "Response",
+    "AbortController",
+    "AbortSignal",
+]);
+/** The native fetch handles (Headers, Request, Response, AbortController,
+ * AbortSignal), optionally in arrays or with null/undefined: checked-dynamic
+ * handles wherever they are stored, like the worker handles above. */
 export function isFetchHandleType(type, ctx) {
     const members = type.isUnionType() ? ts.constituentTypes(type) : [type];
     let handle = false;
@@ -1411,9 +1422,7 @@ export function isFetchHandleType(type, ctx) {
         else {
             const symbol = member.getSymbol();
             if (!symbol ||
-                (ts.symbolName(symbol) !== "Headers" &&
-                    ts.symbolName(symbol) !== "Request" &&
-                    ts.symbolName(symbol) !== "Response") ||
+                !FETCH_HANDLE_NAMES.has(ts.symbolName(symbol)) ||
                 !symbol.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
                     ctx.isStdlibFile(ts.getSourceFileOfNode(d))))
                 return false;
@@ -1967,6 +1976,20 @@ function mapTypeInner(type, ctx) {
             elem = unitOnlyUnion(unions);
         if (!elem)
             return null;
+        // `(T | undefined)[]` of a number, string or boolean T stores T
+        // elements: an array slot holds a present undefined by its own state,
+        // so a T[] seen as `(T | undefined)[]` stays the same array.
+        let optionalElements = false;
+        if (elem.kind === "union") {
+            const arms = unions.get(elem.unionId)?.arms;
+            const present = arms?.length === 2 ? arms.find((arm) => arm.kind !== "undefinedT") : undefined;
+            if (present !== undefined &&
+                arms.some((arm) => arm.kind === "undefinedT") &&
+                (present.kind === "f64" || present.kind === "string" || present.kind === "bool")) {
+                elem = present;
+                optionalElements = true;
+            }
+        }
         // A dyn ELEMENT makes the WHOLE array the checked-dynamic value:
         // `unknown[]`, `object[]`, and the collapsed `(string | object)[]`
         // (the plugins-slot shape) — the checked-dynamic tree has real arrays, so length/
@@ -1990,7 +2013,7 @@ function mapTypeInner(type, ctx) {
         // drain of the auxiliary-server registries): handles are ordinary
         // refcounted REF elements (their `_v` adapters, no trace — both drop
         // their closures at their terminal event).
-        return arrayOf(elem);
+        return optionalElements ? { kind: "array", elem, optionalElements: true } : arrayOf(elem);
     }
     // Tuples: `[string, string]` maps to an interned RECORD shape flagged
     // `tuple`, with one field per position named by its index ("0", "1", ...)
@@ -3705,25 +3728,36 @@ function mapTypeInner(type, ctx) {
             ], 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-
-    // checked like SecureContext; @types/node declares the class inside
-    // `declare module "crypto"`, the shipped fallback mirrors it.
-    // JSON.stringify of one shows the three fields where Node's
-    // internal-slot object shows {} — the Dirent %dtype edge's cousin.
+    // X509Certificate.toLegacyObject()'s PeerCertificate (and tls's detailed
+    // form) is a plain checked-dynamic object.
+    if (psym !== undefined &&
+        (ts.symbolName(psym) === "PeerCertificate" ||
+            ts.symbolName(psym) === "DetailedPeerCertificate") &&
+        psym.declarations.some((d) => ts.isInterfaceDeclaration(d) && ctx.isStdlibFile(ts.getSourceFileOfNode(d)))) {
+        return DYN;
+    }
+    // crypto.X509Certificate — the Dirent-style data record: its fields are
+    // the certificate's lowered members, all computed at construction by the
+    // new-expression lowering (raw decodes the input once, and the others
+    // read raw). Module-checked like SecureContext; @types/node declares the
+    // class inside `declare module "crypto"`, the shipped fallback mirrors
+    // it. JSON.stringify of one shows the fields where Node's internal-slot
+    // object shows {} — the Dirent %dtype edge's cousin.
     if (psym !== undefined &&
         ts.symbolName(psym) === "X509Certificate" &&
         psym.declarations.some((d) => (ts.isInterfaceDeclaration(d) || ts.isClassDeclaration(d)) &&
             ctx.isStdlibFile(ts.getSourceFileOfNode(d)) &&
             isDeclaredInAmbientModule(d, "crypto"))) {
+        const optionalString = withUndefinedArm(STRING, ctx.unions);
+        if (!optionalString)
+            return null;
+        const fields = X509_FIELDS.map(([name, type]) => ({
+            name,
+            type: type === "string?" ? optionalString : type,
+        }));
         return {
             kind: "record",
-            shapeId: ctx.shapes.intern([
-                { name: "fingerprint", type: STRING },
-                { name: "validFrom", type: STRING },
-                { name: "validTo", type: STRING },
-            ], false, undefined, ["fingerprint", "validFrom", "validTo"]),
+            shapeId: ctx.shapes.intern([...fields].sort((a, b) => (a.name < b.name ? -1 : 1)), false, undefined, fields.map((f) => f.name)),
         };
     }
     // perf_hooks' PerformanceEntry, PerformanceMark and PerformanceMeasure
@@ -4093,6 +4127,20 @@ function mapTypeInner(type, ctx) {
         if (record)
             return record;
     }
+    // An intersection whose constituents all map to ONE representation is
+    // that representation. An intersection that restates an optional member
+    // as required (`Opts & { files: Array<{ path: string }> }` over
+    // `files?: Array<{ path: string }>`) gives the member the type `A[] & B[]`
+    // with two separately written but structurally equal element literals;
+    // the checker keeps both, while their arrays (tuples, maps, ...) intern
+    // to one IR type. Reached only after every other intersection rule
+    // declined, so intersections that already mapped keep their mapping. A
+    // dynamic result stays unmapped: two opaque types are not one type.
+    if (widened.isIntersectionType()) {
+        const same = mapEqualConstituentsIntersection(widened, ctx);
+        if (same)
+            return same;
+    }
     // Unions. `boolean` is internally `true | false`, and narrowing produces
     // literal unions like `"a" | "b"` — parts that map to the SAME IR type
     // collapse (deduplicated by typeKey), so a single surviving arm is just
@@ -5807,6 +5855,36 @@ function boundVoidReturnType(p, resolveTypeParam) {
  * result is exactly the nullable-callback shape mapType's union branch
  * admits, `(() => void) | undefined`) so the interned union is IDENTICAL
  * to what mapping the checker's own `T | undefined` produces. */
+/** The X509Certificate record's hidden slot for its publicKey KeyObject,
+ * filled on the first read (builtins/x509.ts). */
+export const X509_PUBLIC_KEY_FIELD = "%publicKey";
+/** The X509Certificate record's hidden copy of its DER, which its methods
+ * read: a program can write into the Buffer `raw` answers, and in Node
+ * that changes neither the certificate's checks nor its PEM. */
+export const X509_DER_FIELD = "%der";
+/** The X509Certificate record's fields in @types/node's declaration order
+ * ("string?" is string | undefined), then the hidden publicKey and DER
+ * slots. */
+export const X509_FIELDS = [
+    ["ca", BOOL],
+    ["fingerprint", STRING],
+    ["fingerprint256", STRING],
+    ["fingerprint512", STRING],
+    ["subject", STRING],
+    ["subjectAltName", "string?"],
+    ["infoAccess", "string?"],
+    ["issuer", STRING],
+    ["raw", { kind: "bytes", elem: "u8" }],
+    ["serialNumber", STRING],
+    ["signatureAlgorithm", "string?"],
+    ["signatureAlgorithmOid", STRING],
+    ["validFrom", STRING],
+    ["validFromDate", DATE_T],
+    ["validTo", STRING],
+    ["validToDate", DATE_T],
+    [X509_PUBLIC_KEY_FIELD, DYN],
+    [X509_DER_FIELD, { kind: "bytes", elem: "u8" }],
+];
 export function withUndefinedArm(t, unions) {
     return withUnitArm(t, "undefinedT", unions);
 }
@@ -5847,6 +5925,21 @@ export function withUnitArm(t, kind, unions) {
  * assigned keys, which is also Node's answer for Object.assign(fn, obj)
  * (a function's own length/name are non-enumerable). Null whenever the
  * shape doesn't fit — the caller falls through to the plain-func mapping. */
+/** The IR type every constituent of an intersection maps to, or null when a
+ * constituent is unmappable or dynamic, or two constituents differ. */
+function mapEqualConstituentsIntersection(widened, ctx) {
+    let same = null;
+    for (const part of ts.constituentTypes(widened)) {
+        const mapped = mapType(part, ctx);
+        if (mapped === null || mapped.kind === "dyn")
+            return null;
+        if (same === null)
+            same = mapped;
+        else if (!typeEquals(same, mapped))
+            return null;
+    }
+    return same;
+}
 function mapHybridCallableIntersection(widened, ctx) {
     const { checker, shapes } = ctx;
     if (!widened.isIntersectionType())
@@ -6116,6 +6209,42 @@ function immutableSourceType(type, ctx) {
     }
     return null;
 }
+/** A mapped type reached through a type alias whose arguments mention no
+ * type parameter (`Record<never, number>`, `Catalog<typeof data, "image">`,
+ * a module-level alias without arguments):
+ * the checker computed its members from concrete inputs, so an empty
+ * result really is the empty object type, unlike `Partial<T>` inside a
+ * generic body. */
+function resolvedMappedAlias(t, ctx) {
+    if (!isMappedShape(t) || t.getAliasSymbol() === undefined)
+        return false;
+    const args = t.getAliasTypeArguments();
+    const seen = new Set();
+    const concrete = (part) => {
+        if (part.flags & (ts.TypeFlags.TypeParameter | ts.TypeFlags.Index))
+            return false;
+        if (part.flags & (ts.TypeFlags.IndexedAccess | ts.TypeFlags.Conditional))
+            return false;
+        if (seen.has(part))
+            return true;
+        seen.add(part);
+        if (part.isUnionType() || part.isIntersectionType())
+            return ts.constituentTypes(part).every(concrete);
+        if (!part.getAliasTypeArguments().every(concrete))
+            return false;
+        return ((part.flags & ts.TypeFlags.Object) === 0 ||
+            (part.objectFlags & ts.ObjectFlags.Reference) === 0 ||
+            ctx.checker.getTypeArguments(part).every(concrete));
+    };
+    // An alias without type arguments is concrete when it is declared at
+    // module level (a function body's alias may mention that function's type
+    // parameters).
+    if (args.length === 0)
+        return t
+            .getAliasSymbol()
+            .declarations.every((d) => ts.isTypeAliasDeclaration(d) && (ts.isSourceFile(d.parent) || ts.isModuleBlock(d.parent)));
+    return args.every(concrete);
+}
 /** 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
@@ -7018,8 +7147,11 @@ function mapRecordTypeInner(widened, ctx) {
         // still unknown there) — interning `{}` would give a wrong type. The
         // degenerate empties (`Partial<{}>`, `Omit<C, keyof C>`) go with it.
         // An INDEX-SIGNATURE shape is exempt: `Record<string, T>` legitimately
-        // has zero declared members — the signature is the shape.
-        if (computed && props.length === 0 && !indexValue)
+        // has zero declared members — the signature is the shape. So is a mapped
+        // alias instantiated over concrete arguments (`Record<never, T>`, a
+        // catalog type whose key filter keeps no key): the checker resolved it,
+        // and it is the empty object type below.
+        if (computed && props.length === 0 && !indexValue && !resolvedMappedAlias(widened, ctx))
             return null;
         // An empty object type — `{}` (spelled, the checker's shared
         // intrinsic, or inferred from an empty object literal), `interface