@scriptc/compiler 0.4.0 → 0.4.2

package/dist/frontend/type-mapper.d.ts

@@ -9,6 +9,10 @@ export declare function jsOpenObjectType(decl: ts.Node | undefined, type: IrType
  * global, SubtleCrypto, CryptoKey handles and the algorithm dictionaries
  * (scr_webcrypto.c). */
 export declare const WEBCRYPTO_DYN_TYPES: ReadonlySet<string>;
+/** 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 declare const CRYPTO_KEY_OPTION_DYN_TYPES: ReadonlySet<string>;
 export declare const FETCH_AMBIENT_TYPES: readonly ["Response", "Request", "ResponseInit", "RequestInit", "Event", "CustomEvent", "MessageEvent", "EventTarget", "AddEventListenerOptions", "EventListenerOptions", "EventInit", "CustomEventInit", "AbortController", "AbortSignal", "Headers", "ReadableStream", "ReadableStreamDefaultReader", "ReadableStreamDefaultController", "ReadableStreamReadResult", "ReadableStreamReadValueResult", "ReadableStreamReadDoneResult", "Blob", "File", "BlobPropertyBag", "FilePropertyBag", "BlobOptions", "FileOptions"];
 /** node:crypto's Cipheriv and Decipheriv names in @types/node. */
 export declare const CIPHER_TYPE_NAMES: ReadonlySet<string>;
@@ -27,6 +31,8 @@ export type DeclaredOrderPriority = readonly number[] | DeclaredOrderPriorityRef
 export declare class ShapeRegistry {
     /** Existing layouts change only when a recursive placeholder closes. */
     revision: number;
+    /** Each shape id with a second hash of its key (keyedHelperName). */
+    readonly keyedNameKeys: Map<string, number>;
     private readonly byKey;
     private readonly byId;
     /** Historical emit-order rank of the declaration-order metadata each
@@ -42,7 +48,7 @@ export declare class ShapeRegistry {
      * writer after all priority candidates have closed. */
     private readonly derivedDeclaredOrderFinalizers;
     private currentDeclaredOrderPriority;
-    /** All interned shapes in first-seen (`r0`, `r1`, ...) order. */
+    /** All interned shapes in first-seen order. */
     readonly shapes: IrRecordShape[];
     /** ts.Types currently being mapped — a BACK-REFERENCE to one of these is
      * the recursive knot (`interface TreeNode { children: TreeNode[] }`):
@@ -87,8 +93,9 @@ export declare class ShapeRegistry {
     declaredOrderFinalizer(shapeId: string, originalOrder: string[], order: () => string[] | undefined): () => void;
     /** 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: ts.Type): string;
+     * entry (empty fields) the outer frame finalizes. `describe` names a new
+     * placeholder (checkerTypeDescription). */
+    recursiveRef(t: ts.Type, describe: () => string): string;
     /** The FINALIZED recursive shape for a checker type — undefined while
      * never mapped, mid-construction, or permanently failed. */
     recursiveShapeFor(t: ts.Type): string | undefined;
@@ -135,6 +142,13 @@ export declare class ShapeRegistry {
         type: IrType;
     }[]): void;
 }
+/** 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 declare function checkerTypeDescription(t: ts.Type, ctx: Pick<TypeMapperCtx, "checker" | "positionOf">, depth?: number): string;
 /** 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.
@@ -142,10 +156,12 @@ export declare class ShapeRegistry {
 export declare class UnionRegistry {
     /** Existing arm/discriminator contracts change when a placeholder closes. */
     revision: number;
+    /** Each union id with a second hash of its key (keyedHelperName). */
+    readonly keyedNameKeys: Map<string, number>;
     private readonly byKey;
     private readonly byId;
     private readonly armTags;
-    /** All interned unions in first-seen (`u0`, `u1`, ...) order. */
+    /** All interned unions in first-seen order. */
     readonly unions: IrUnionDef[];
     /** ts.Types currently being mapped — a back-reference to one is the
      * recursive knot passing through a union (`type Tree = Leaf | Branch`
@@ -160,8 +176,9 @@ export declare class UnionRegistry {
     private readonly pendingRec;
     /** 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: ts.Type): string;
+     * entry (empty arms) the outer frame finalizes. `describe` names a new
+     * placeholder (checkerTypeDescription). */
+    recursiveRef(t: ts.Type, describe: () => string): string;
     /** The FINALIZED recursive union for a checker type — undefined while
      * never mapped, mid-construction, or permanently failed. */
     recursiveUnionFor(t: ts.Type): string | undefined;
@@ -262,7 +279,22 @@ export type TypeParamTsResolver = (t: ts.Type) => ts.Type | null;
  * once per Lowerer and threaded through the recursion — adding a hook means
  * one new field here, not a new parameter at every call site. */
 export interface TypeMapperCtx {
+    /** Set only while a union maps an arm that is the type inferred from an
+     * empty object literal, beside another non-nullish arm: that arm holds
+     * only the literal's objects, so it maps to the empty record (see the
+     * empty object type rule in the object mapping). */
+    emptyLiteralArm?: boolean;
+    /** The class value a generic factory's result type names when the factory
+     * returns one of its own local classes through a constructor type
+     * (`function struct<S>(v: S): Struct<S> { class Base {}; return Base as
+     * Struct<S>; }`), by the checker type: the declared result inside the
+     * instance being lowered, the instantiated result at its calls. */
+    localClassValue?: (type: ts.Type) => IrType | null;
     checker: ts.TypeChecker;
+    /** The structural position of a declaration (structural-positions.ts),
+     * which names recursive placeholders independently of where unrelated
+     * code sits. The Lowerer supplies it. */
+    positionOf?: (node: ts.Node) => string;
     /** JavaScript declarations whose instance or object-literal types only
      * the checked-dynamic representation holds (js-dynamic-objects.ts).
      * Absent when the program has none: every mapping is unchanged. */