@scriptc/compiler 0.4.3 → 0.4.5

package/dist/backend/llvm/dyn.d.ts

@@ -1,4 +1,5 @@
 import type { IrRecordShape, IrType } from "../../ir/ir.js";
+import { BlockBuilder } from "./blocks.js";
 import type { WalkerHost } from "./walkers.js";
 import type { LlStreamTypedRefAdapter } from "./expr-context.js";
 /** Whether to-dyn of a record shape keeps the record itself: an empty shape
@@ -11,7 +12,7 @@ export declare function recordDynKeepsIdentity(shape: IrRecordShape): boolean;
 export declare const DYN_HANDLE_TAG_NUM: Record<string, number>;
 /** The handle tags of TextEncoder and TextDecoder records boxed as dyn
  * (scr_dyn.h; scr_text_codec_dyn.c boxes and unboxes them). */
-export declare const TEXT_CODEC_TAG_NUM: Record<"TextEncoder" | "TextDecoder", number>;
+export declare const TEXT_CODEC_TAG_NUM: Record<"TextEncoder" | "TextDecoder" | "StringDecoder", number>;
 export declare const DYN_KIND: {
     readonly NULL: 0;
     readonly BOOL: 1;
@@ -54,6 +55,10 @@ export interface DynHost extends WalkerHost {
     dynPromiseAdapter(t: IrType): string;
     isErrorClass(className: string): boolean;
     classSubtypes(className: string): readonly string[];
+    /** The strict subclasses whose class-value constructor takes the same
+     * arguments as `className`'s (classValueAbiEquals): the class values a
+     * checked `classval` slot accepts besides its own class. */
+    classValueSubtypes(className: string): readonly string[];
     /** emitter.ts's pendingTestLines: the inline pending-exception test. */
     pendingTestLines(dest: string): string[];
 }
@@ -107,6 +112,19 @@ export declare class LlDyn {
     /** In a recursive shape's builder body: record `value`, just allocated
      * for %d, before its members are built. */
     private recordBuilt;
+    /** Whether a builder of `def` may pick a plain object's arm by its literal
+     * discriminator alone inside a trusted build (scr_dyn_trust_enter): the
+     * arms' literals are disjoint, and every arm without a literal has a kind
+     * no plain object matches. The value then matched exactly one arm with a
+     * literal, the arm whose literal it carries. */
+    private trustedArmByLiteral;
+    /** Per arm of `def`, the dyn kind of the values a builder may convert into
+     * that arm without matching its structure inside a trusted build, or null.
+     * A value there already matched one of the union's arms, so the arm is
+     * known when it is the only arm that takes values of its kind: the arm
+     * whose literal a plain object carries (trustedArmByLiteral), or the one
+     * arm a plain object or an array can match at all. */
+    private trustedArmKinds;
     /** The order a dyn value tries a union's arms in: the canonical order,
      * except that among the record arms, those with more required fields go
      * first, then those with more fields. Records are width-tolerant, so an
@@ -114,9 +132,34 @@ export declare class LlDyn {
      * matches every object) would otherwise take an object that a wider arm
      * also matches and drop the fields only the wider arm has. */
     private unionArmOrder;
+    /** The string literals of `def`'s discriminant when its arms are chosen
+     * by reading the discriminant once (unionArmsByDiscriminant), or null
+     * when the union keeps one literal test per arm: some literal is not a
+     * string, or there are fewer than DISCRIMINANT_DISPATCH_VALUES. */
+    private dispatchValues;
+    /** Branches to `hits[tag]` for the first arm in `order` that `%d` matches
+     * (unionArmMatch), or to `none` when no arm does, for
+     * a union whose discriminant literals are `values` (dispatchValues). The
+     * discriminant is read once (scr_dyn_discriminant_case, against the
+     * constant `table`), and only the arms whose literal it holds and the arms
+     * without a literal are tested, in `order`: every other arm's literal test
+     * fails. An arm's failed check can run a getter that changes the
+     * discriminant, so it is read again after each one; when its case
+     * changed, the tests continue arm by arm after the failed arm, as they
+     * would have run from the first arm. A value the runtime cannot classify
+     * that way (a typed capsule, an accessor, an inherited discriminant) takes
+     * the tests arm by arm. */
+    private unionArmsByDiscriminant;
     /** Branch to a variant only after its literal discriminator and complete
-     * structure match. Use the same path for predicates and builders. */
+     * structure match. Use the same path for predicates and builders. With a
+     * `trustedKind` (builders, trustedArmKinds), a value of that dyn kind
+     * inside a trusted build skips the structure match once its literal
+     * matched. */
     private unionArmMatch;
+    /** The part of unionArmMatch past the arm's literal test. With a
+     * `trustedKind`, a value of that dyn kind inside a trusted build skips the
+     * structure match. */
+    private unionArmStructure;
     private get S();
     private abiOffset;
     private get indexMaxDiv10();
@@ -124,6 +167,8 @@ export declare class LlDyn {
     private valTy;
     private collectionDynOps;
     /** Loads a dyn node's kind tag (after the size_t rc word). */
+    /** i1: the checked-dynamic value `d` is undefined. */
+    isUndefined(B: BlockBuilder, d: string): string;
     private kindOf;
     /** Loads the 8-byte payload slot at +16 as the given LLVM type. */
     private payloadOf;
@@ -210,9 +255,18 @@ export declare class LlDyn {
      * fields, and at least one unless an index signature collects the
      * members), record members typed as unions of those leaves, records and
      * arrays, null and undefined (optional and nullable members; see
-     * jsonUnionSupported), and index signatures whose value type is not a
-     * union. Everything else keeps the checked-dynamic route alone. */
+     * jsonUnionSupported), discriminated unions of records anywhere (see
+     * jsonDiscriminatedSupported), and index signatures whose value type is
+     * not a union. Everything else keeps the checked-dynamic route alone. */
     private jsonSchemaSupported;
+    /** A discriminated union the one-pass parser writes directly, as a record
+     * member, an array element or the whole document: record arms that each
+     * name the string literals their discriminant member holds, every
+     * literal naming one arm, plus null and undefined arms. An object then
+     * selects the one arm whose literal its discriminant member holds, the
+     * only arm the checked route's literal tests leave to match
+     * (unionArmsByDiscriminant); an object holding no such literal declines. */
+    private jsonDiscriminatedSupported;
     /** A union record member the one-pass parser writes directly: every arm
      * a number, boolean, string, null, undefined, or a supported record or
      * array, with at most one record and one array arm and no discriminant.
@@ -227,8 +281,15 @@ export declare class LlDyn {
     /** The ScrJsonUnion descriptor of a union member (scr_json.h layout):
      * its slot representation, the arm each JSON value kind selects, and the
      * values the runtime stores for null and for a missing member. Boxed
-     * unions build their boxes through `<name>_box`. */
+     * unions build their boxes through `<name>_box`. A discriminated union
+     * also lists its object arms by discriminant literal (`<name>_cases`),
+     * and, because it can be an array element or a whole document, whose
+     * values are boxes unless the union is a pointer union, it keeps its null
+     * value and box whatever its field representation. */
     private jsonUnionSchema;
+    /** `record.sourceSpread(built, value)`: the built record keeps value's
+     * kept-source order over its own declared names. */
+    emitRecordSourceSpread(B: BlockBuilder, built: string, value: string, shapeId: string): void;
     /** The declared-name tables scr_record_source_note scans: parallel
      * constant arrays of field-name bytes and byte lengths in declaration
      * order (the order the record serializes), interned per shape. Internal
@@ -247,9 +308,9 @@ export declare class LlDyn {
     dynCheckHelper(t: IrType, preserveRefs?: boolean): string;
     /** `i1`: %d is a handle box with tag `tag`. */
     private handleTagMatches;
-    /** A TextEncoder or TextDecoder record boxes as its handle (+1), which
-     * holds the record by reference. A decoder passes the byte offsets of the
-     * fields its boxed decode reads. */
+    /** A TextEncoder, TextDecoder or StringDecoder record boxes as its
+     * handle (+1), which holds the record by reference. The decoders pass
+     * the byte offsets of the fields their boxed methods read. */
     private textCodecToDyn;
     /** `sc_td_<n>(<T> v) -> ptr` — build a fresh dyn value from a
      * static one (+1), DEEP-COPYING composites. Borrows the operand.