@yabgu_gm/tensionscript 0.13.0 → 0.13.2

package/dist/assemblyscript.generated.d.ts

@@ -6730,6 +6730,79 @@ declare module "types:tensionscript/src/compiler" {
          * value materialised somewhere, which is the return path, not this one.
          */
         private expandSroaArrayArgument;
+        /**
+         * Compiles an array literal into one operand per element leaf, starting at
+         * `at`, and returns how many were written.
+         *
+         * The operand sink of `emitSroaArrayLiteralLeaves`: the walk yields the leaves
+         * and this places them, then fills any element the literal omitted — a WASM
+         * operand cannot be left out, even when a local could (`fillSroaArrayFromLiteral`,
+         * where zero is free).
+         */
+        private pushSroaArrayLiteralOperands;
+        /**
+         * Compiles an array literal into one **leaf expression per leaf**, appended to
+         * `leaves` in element-major order.
+         *
+         * **The one array-literal element walk.** Three positions use it: the call site
+         * (`pushSroaArrayLiteralOperands`), the return
+         * (`compileMultivalueReturnStatement`), and the local declaration
+         * (`fillSroaArrayFromLiteral`). A value-form array's elements are leaves, and
+         * the positions differ only in what they do with them — push operands, make a
+         * tuple, or `local.set` — so the rules for *reading* a literal live here once.
+         *
+         * `verb` is `"passing"`, `"returning"` or `"initializing"`; it only chooses
+         * the wording of the refusals.
+         *
+         * The elements a literal omits are **not** produced here: a WASM local starts
+         * at zero, so a local declaration needs no stores for them, while an argument
+         * or a return needs an operand and the caller fills it (`makeZero` per leaf
+         * type). Two different destinations, one walk.
+         *
+         * A **long** literal is an arity error rather than a write past the leaf
+         * block — `sum([1, 2, 3, 4, 5])` into a `[u32 * 4]` parameter reached Binaryen
+         * with five operands for four slots and crashed the compiler, so this bound is
+         * a guard, not a formality.
+         *
+         * A **record** element is several leaves, so it is read one leaf per field: an
+         * object literal (`{ x: 1.5, y: 2.5 }`) compiles straight to them
+         * (`emitSroaObjectElementLeaves`), and anything else — a record local, a call —
+         * is refused by name, because a local there is a pointer, not the leaves.
+         */
+        private emitSroaArrayLiteralLeaves;
+        /**
+         * Compiles one **object literal** element of a `[T * N]` array literal into
+         * that element's field leaves, in declaration order.
+         *
+         * `{ x: 10.5, y: 20.5 }` is the natural way to write a record element, and for
+         * an `@unmanaged struct` it can be compiled straight to leaves — no heap
+         * record, no constructor, no pointer. The class path (`compileObjectLiteral`)
+         * cannot be reused for it: that one requires a class, takes a temp local of
+         * that class, and returns one reference, because it has to produce an
+         * *address*. Measured on the same spelling: `const p: P = { x: 10.5 }` emits
+         * `P#constructor` plus `__alloc(16)` and setters — a heap record, not a value.
+         *
+         * Policies, each measured against the class path so the two spellings agree:
+         *
+         * - **Declaration order.** Fields are emitted in the record's declaration
+         *   order, not the literal's, because the leaves are positional.
+         * - **Last duplicate wins** — `{ x: 1.0, x: 2.0 }` is `2.0`, as measured for
+         *   `const p: P = { x: 1.0, x: 2.0 }`.
+         * - **An unknown name is an error** at the name, matching
+         *   `compileObjectLiteral`'s `TS2339`.
+         * - **An omitted field takes its declared default**, matching the constructor
+         *   the class path runs: measured, `{ x: 10.0 }` on `{ x = 5.0; y = 7.0 }`
+         *   yielded `y = 7.0`, not `0`. Only a **constant** default is reproduced
+         *   here; one that needs the record instance (`y = this.x * 2.0`) is refused
+         *   by name, because a leaf emission has no instance to evaluate it against.
+         * - **A field left with no default is zero**, matching `{ x: 3.0 }` on a record
+         *   with no initialisers (measured: `y` came back `0`).
+         *
+         * A **nested** field (an `@inline struct` inside the record) is refused: its
+         * value is a second set of leaves behind a second object literal, which is the
+         * recursion this landing does not carry.
+         */
+        private emitSroaObjectElementLeaves;
         private expandSroaArgument;
         /**
          * The SROA local an expression names, or `null`.
@@ -6755,6 +6828,18 @@ declare module "types:tensionscript/src/compiler" {
          * carrying its own map, so the walk descends through it.
          */
         private pushSroaLeafOperands;
+        /**
+         * Collects a `fieldLocals` tree's leaves into `out`, depth first.
+         *
+         * **The one definition of leaf order.** A nested value is a placeholder
+         * (index `-1`) carrying its own map, so the walk descends through it rather
+         * than yielding it. Every emitter that needs "the leaves of this value, in
+         * order" goes through here — `pushSroaLeafOperands` for call operands, the
+         * array-literal walk for literal elements, the local binder for stores — so
+         * order is stated once instead of re-derived per site. It must agree with
+         * `Signature.leafTypesOf`, which is the type-level twin.
+         */
+        private collectSroaLeafLocals;
         private resolveSroaReceiver;
         /** Size of the static call-temp region, in bytes. 4 KB is 256 slots at the
          *  16-byte fixture record size. Overflow aborts (see `makeSretCallBlock`);
@@ -7066,14 +7151,18 @@ declare module "types:tensionscript/src/compiler" {
         /**
          * Stores an array literal's elements into a value-form array's leaves.
          *
-         * A scalar element is compiled straight into its leaf. A **record** element is
-         * several leaves and a literal cannot name them one at a time, so it is
-         * refused by name here rather than compiled: the object-literal spelling
-         * (`{ x: 1.5, y: 2.5 }`) goes through the class path and *allocates* — measured,
-         * `const p: P = { x: 1.5 }` emitted `P#constructor` plus setters and needed
-         * `env.abort`, i.e. a heap record behind a pointer, which is not a value.
-         * Initialising the elements field by field (`arr[0].x = 10.5`) is the working
-         * route, and it is what the diagnostic says.
+         * The **local-declaration sink** of `emitSroaArrayLiteralLeaves`: the walk
+         * yields one expression per leaf in element-major order, and this local's
+         * leaves were created in the same order (`fillSroaArrayLocals` keys them
+         * `"0"`, `"1"`, ...), so the two line up positionally and a `local.set` per
+         * pair is the whole job. No zero-fill: a WASM local starts at zero, so an
+         * omitted element needs no store — which is why the walk does not produce one.
+         *
+         * A scalar element is one leaf. A **record** element is several, and the walk
+         * refuses it by name: the object-literal spelling (`{ x: 1.5, y: 2.5 }`) goes
+         * through the class path and *allocates* — measured, `const p: P = { x: 1.5 }`
+         * emitted `P#constructor` plus setters and needed `env.abort`, i.e. a heap
+         * record behind a pointer, which is not a value.
          */
         private fillSroaArrayFromLiteral;
         /**
@@ -7166,9 +7255,10 @@ declare module "types:tensionscript/src/compiler" {
          * Returns a value-form `[T * N]` value as WASM multivalue results.
          *
          * One result per element leaf, element-major — the order `resultRefs` declares
-         * and the caller's unpack indexes into. The leaves are read out of the value's
-         * SROA locals; a fresh array literal goes through the same path, because the
-         * literal binds to leaves before the return is compiled.
+         * and the caller's unpack indexes into. Two shapes reach here, and both end as
+         * one operand per leaf: a value-form local pushes its SROA leaves, and a fresh
+         * array literal compiles element by element through the same walk the call
+         * site uses (`pushSroaArrayLiteralOperands`).
          *
          * Requires `Feature.MultiValue`, which `Resolver` turns on when it resolves
          * this return type (`enableMultiValueOnce`), so a module that returns one of