@yabgu_gm/tensionscript 0.12.0 → 0.13.0

package/dist/assemblyscript.generated.d.ts

@@ -2414,6 +2414,23 @@ declare module "types:tensionscript/src/types" {
         fixedElementType: Type | null;
         /** Element count of a {@link TypeKind.FixedArray}, else `0`. */
         fixedLength: number;
+        /**
+         * Who owns a {@link TypeKind.FixedArray}'s storage — the second axis of the
+         * kind, alongside the element and the length.
+         *
+         * The memory model was already on the AST (`TypeNode.memoryModel`) and was
+         * simply dropped before Landing 5a.5: `Type.fixedArray` interned one object
+         * per `(element, length)`, so `[u32 * 4]`, `@unmanaged [u32 * 4]`,
+         * `@managed [u32 * 4]` and `@inline [u32 * 4]` were **the same Type**, and
+         * the prefix was decorative — measured, all four emitted identical code.
+         *
+         * The two forms are not the same thing. `[u32 * 4]` is 16 bytes of inline
+         * elements with no address of its own; `@unmanaged [u32 * 4]` is a pointer to
+         * four elements, i.e. 4 bytes. Part of {@link equals} for the same reason
+         * {@link dynamicMemoryModel} is: interning them together would make the two
+         * spellings the same object, and no downstream test could tell them apart.
+         */
+        fixedMemoryModel: MemoryModelCode;
         /**
          * Element type of a {@link TypeKind.UnmanagedArray}, else `null`.
          *
@@ -2437,12 +2454,16 @@ declare module "types:tensionscript/src/types" {
          */
         dynamicMemoryModel: MemoryModelCode;
         /**
-         * Alignment (log2) of a {@link TypeKind.FixedArray}: its element's.
+         * Alignment (log2) of a {@link TypeKind.FixedArray}.
+         *
+         * For the **value** form this is the element's. `alignLog2` cannot derive
+         * that from `byteSize` -- a 24-byte `f32[6]` would report 16-byte alignment
+         * (`31 - clz(24)` = 4), and a 96-byte `f32[24]` would report 64. An array is
+         * aligned as its element is, no matter how long it is, so the value is carried
+         * rather than computed.
          *
-         * `alignLog2` cannot derive this from `byteSize` -- a 24-byte `f32[6]` would
-         * report 16-byte alignment (`31 - clz(24)` = 4), and a 96-byte `f32[24]` would
-         * report 64. An array is aligned as its element is, no matter how long it is,
-         * so the value is carried rather than computed.
+         * For the **view** form it is the *pointer's*, because that is what the value
+         * is: the extent says nothing about how the address is aligned.
          */
         private fixedAlignLog2;
         /** Respective non-nullable type, if nullable. */
@@ -2518,6 +2539,34 @@ declare module "types:tensionscript/src/types" {
         get isManaged(): boolean;
         /** Tests if this is a class type explicitly annotated as unmanaged. */
         get isUnmanaged(): boolean;
+        /**
+         * This type's extent in bytes when it is stored **inline**, rather than by
+         * reference.
+         *
+         * For a scalar the two are the same number, and for an ordinary class neither
+         * is what an inline array wants -- a class element is stored as its 4-byte
+         * reference, so `byteSize` is right there. The one case where `byteSize` is
+         * **wrong** is a C-layout record (`@unmanaged` / `@managed struct`, and
+         * `@inline struct`, which the parser also flags `@unmanaged`): there
+         * `byteSize` is the reference width (4) while the bytes an inline element
+         * actually occupies are the record's layout size, `Class#nextMemoryOffset`.
+         *
+         * That is the same pair `builtin_sizeof` distinguishes
+         * (`builtins.ts`, the `Unmanaged | ManagedStruct` branch), and it is why
+         * `sizeof<Props>()` answered 16 while `sizeof<[Props * 4]>()` answered 16
+         * instead of 64: the array's size was built from the reference width.
+         */
+        get inlineExtentBytes(): number;
+        /**
+         * This type's alignment as a log2 when it is stored inline.
+         *
+         * A record's alignment is the strongest of its fields', accumulated while the
+         * resolver lays it out (`Class#alignLog2`), and **not** `Type#alignLog2` —
+         * which reads the class's 4-byte reference size and would report 2 for every
+         * record, including one aligned to 8. The same distinction `builtin_alignof`
+         * makes, for the same reason.
+         */
+        get inlineAlignLog2(): number;
         get isMemory(): boolean;
         /** Gets the corresponding non-nullable type. */
         get nonNullableType(): Type;
@@ -2592,19 +2641,39 @@ declare module "types:tensionscript/src/types" {
         /** A 32-bit float. */
         static readonly f32: Type;
         /** A 64-bit float. */
-        /** Interned fixed-array types, keyed by element type and length. */
+        /** Interned fixed-array types, keyed by model, element type and length. */
         private static _fixedArrays;
         /**
-         * Gets the {@link TypeKind.FixedArray} of `elementType` repeated `length` times.
+         * Gets the {@link TypeKind.FixedArray} of `elementType` repeated `length`
+         * times, in the storage named by `memoryModel`.
+         *
+         * Interned: the same `(model, element, length)` always yields the same `Type`,
+         * so `offsetof`, `alignof`, `sizeof` and field lookup can compare by identity
+         * the way they do for every other type.
+         *
+         * **The model is part of the identity**, and that is the point of Landing
+         * 5a.5. Before it, this function had one axis (element, length) and the memory
+         * model was dropped, so `[u32 * 4]` and `@unmanaged [u32 * 4]` were the same
+         * Type object — measured: both compiled, both `sizeof` 16, and all four
+         * spellings (`[T * N]`, `@unmanaged [T * N]`, `@managed [T * N]`,
+         * `@inline [T * N]`) emitted byte-identical code. A prefix that changes
+         * nothing is worse than one that is refused, because it reads as if it means
+         * something.
          *
-         * Interned: the same element and length always yield the same `Type`, so
-         * `offsetof`, `alignof`, `sizeof` and field lookup can compare by identity the
-         * way they do for every other type. Size is the element's byte size times the
-         * length, and the alignment is the element's -- carried in
-         * {@link fixedAlignLog2} rather than derived from the total, because a total
-         * is not a power of two for the lengths records actually have (`f32[6]`).
+         * The two honourable forms differ in both size and alignment:
+         *
+         *   value  (`Any` / `Inline`) — inline elements: `elementSize * length` bytes,
+         *                               aligned as the element is
+         *   view   (`Unmanaged`)      — one address: `pointerSize` bits, aligned as a
+         *                               pointer is
+         *   heap   (`Managed`)        — one GC reference, same shape as the view; the
+         *                               form itself is refused until Landing 5c, but
+         *                               the Type can be built so that `sizeof` answers
+         *                               the truth before the refusal fires
+         *
+         * `pointerSize` is in **bits**, matching `Type.size`.
          */
-        static fixedArray(elementType: Type, length: number): Type;
+        static fixedArray(elementType: Type, length: number, memoryModel: MemoryModelCode, pointerSize: number): Type;
         /** Gets the element type of a {@link TypeKind.FixedArray}. */
         get fixedArrayElementType(): Type;
         /** Interned unmanaged-array types, keyed by element type and pointer width. */
@@ -3370,6 +3439,31 @@ declare module "types:tensionscript/src/resolver" {
          * collection wants `Array<T>`, and letting `T[N]` hold references would make
          * `@unmanaged` records carry GC edges they cannot describe. Refused by name.
          */
+        /**
+         * Turns on `Feature.MultiValue` the first time a value-form `[T * N]` return
+         * type is resolved.
+         *
+         * **At resolution, not at emission.** The module's feature flags are computed
+         * once, in `Compiler`'s constructor (`module.setFeatures`), and a return is
+         * emitted long after that — so this sets the option *and* re-sets the module's
+         * flags, which `setFeatures` supports (`module.ts`). Measuring that
+         * re-settability is what this hook rests on: with a write-once flags word this
+         * would have needed a deferred second pass.
+         *
+         * Policy is **auto-enable** rather than a required flag: a consumer who writes
+         * `function make(): [T * N]` should not have to know that the emitter lowers it
+         * to multivalue results. The trade is that the module's declared feature set
+         * depends on its source, which is exactly the contract `--exportRuntime`
+         * already sets. A module that never returns one never gets the flag.
+         *
+         * Idempotent: `features` is a bitmask, and re-setting the same flags is a
+         * no-op for binaryen.
+         */
+        private enableMultiValueForArrayReturn;
+        /** Whether `type` is a fixed array in its **value** form — N inline elements
+         *  with no address of their own — as opposed to the `@unmanaged` view (a
+         *  pointer) or the `@managed` heap form (Landing 5c). */
+        private isValueFormFixedArray;
         private resolveFixedArrayType;
         /**
          * Resolves an {@link UnmanagedArrayTypeNode} to a
@@ -4016,7 +4110,7 @@ declare module "types:tensionscript/src/program" {
     import { Type, Signature } from "types:tensionscript/src/types";
     import { Token } from "types:tensionscript/src/tokenizer";
     import { Node, Source, DecoratorNode, DecoratorKind, TypeParameterNode, TypeNode, NamedTypeNode, FunctionTypeNode, ArrowKind, Expression, IdentifierExpression, Statement, ClassDeclaration, DeclarationStatement, EnumDeclaration, EnumValueDeclaration, FieldDeclaration, FunctionDeclaration, InterfaceDeclaration, NamespaceDeclaration, TypeDeclaration, VariableDeclaration, VariableLikeDeclarationStatement } from "types:tensionscript/src/ast";
-    import { Module, ExpressionRef, FunctionRef, MemorySegment } from "types:tensionscript/src/module";
+    import { Module, ExpressionRef, FunctionRef, MemorySegment, TypeRef } from "types:tensionscript/src/module";
     import { Resolver } from "types:tensionscript/src/resolver";
     import { Flow } from "types:tensionscript/src/flow";
     import { Parser } from "types:tensionscript/src/parser";
@@ -4800,6 +4894,29 @@ declare module "types:tensionscript/src/program" {
          * therefore cannot alias.
          */
         fieldLocals: Map<string, Local> | null;
+        /**
+         * The WASM slot type for this local, when it is **not** what {@link type}
+         * says it is.
+         *
+         * `type` answers "what does the source see" — a record, so `p.field` resolves;
+         * an array, so `arr[i]` resolves. The slot is a different question, and for
+         * most locals the two agree. Three cases where they do not:
+         *
+         * - **view local** (`isViewLocal`) — the slot is the pointer; handled below by
+         *   substituting `usizeType`, because a pointer *is* a type.
+         * - **multivalue tuple** — the slot is the `TypeRef` binaryen makes for a
+         *   multi-result signature. That has **no `Type` at all**: `createType(refs)`
+         *   answers a `TypeRef` the type system cannot describe. Hence an override
+         *   rather than a substitution — this is the one local whose slot cannot be
+         *   named by a `Type`.
+         *
+         * {@link TypeRef.None} for every other local, so the ordinary case costs
+         * nothing — the same reasoning as {@link fieldLocals}. A sentinel rather than
+         * `| null` because `TypeRef` is an integer type and cannot be nullable here
+         * (measured: `AS204: Type 'TypeRef' cannot be nullable` when the self-hosted
+         * compiler parsed this declaration).
+         */
+        typeRefOverride: TypeRef;
         /**
          * Whether this local is a **view parameter**: `a: @unmanaged T` where `T` is
          * an inline type.
@@ -4955,6 +5072,23 @@ declare module "types:tensionscript/src/program" {
          * one structure regardless of where the leaves' storage came from.
          */
         bindSroaParameterLeaves(type: Type, path: string, into: Map<string, Local>, localIndex: number, flow: Flow): BindResult;
+        /**
+         * Binds a value-form `[T * N]` parameter's **leaves** to the WASM parameters
+         * that carry them.
+         *
+         * The array sibling of {@link bindSroaParameterLeaves}, and the same tree
+         * shape `fillSroaArrayLocals` builds for a local: the map is keyed `"0"`,
+         * `"1"`, ... and a record element is a placeholder carrying its field leaves.
+         * What differs is where the leaves' storage comes from — incoming parameters
+         * here, fresh locals there.
+         *
+         * Element-major, matching `Signature.leafTypesOf` and the caller's operand
+         * order. A parameter is a **value** for the callee's whole body: nothing is
+         * written back, so a store to `arr[0].x` is invisible to the caller. That is
+         * the copy semantics the representation is for, and it costs nothing extra —
+         * the leaves are separate slots precisely because the value has no address.
+         */
+        bindSroaArrayParameterLeaves(type: Type, path: string, into: Map<string, Local>, localIndex: number, flow: Flow): BindResult;
         /** Constructs a new concrete function. */
         constructor(
         /** Name incl. type parameters, i.e. `foo<i32>`. */
@@ -4967,8 +5101,23 @@ declare module "types:tensionscript/src/program" {
         signature: Signature, // pre-resolved
         /** Contextual type arguments inherited from its parent class, if any. */
         contextualTypeArguments?: Map<string, Type> | null);
-        /** Gets the types of additional locals that are not parameters. */
-        getNonParameterLocalTypes(): Type[];
+        /**
+         * The **WASM slot types** of the additional locals that are not parameters.
+         *
+         * Named for the refs rather than the types because that is what it now
+         * answers: most slots are `local.type.toRef()`, but a multivalue tuple's slot
+         * is a `TypeRef` with no `Type` behind it ({@link Local.typeRefOverride}), and
+         * a view local's slot is the pointer rather than the record it names. Callers
+         * feed this straight to `Module#addFunction`'s `varTypes`, which is a
+         * `TypeRef[]` — so the conversion belongs here, where the slot is decided,
+         * rather than at each of them.
+         *
+         * Renamed from `getNonParameterLocalTypes` when the tuple override landed:
+         * four call sites all wrapped the old answer in `typesToRefs`, and renaming
+         * means a caller that was missed fails to compile instead of silently
+         * declaring a slot of the wrong type.
+         */
+        getNonParameterLocalTypeRefs(): TypeRef[];
         /** Gets the name of the parameter at the specified index. */
         getParameterName(index: number): string;
         /** Creates a stub for use with this function, i.e. for varargs or override calls. */
@@ -6474,6 +6623,42 @@ declare module "types:tensionscript/src/compiler" {
         addDebugLocation(expr: ExpressionRef, range: Range): void;
         /** Checks whether a particular function signature is supported. */
         checkSignatureSupported(signature: Signature, reportNode: FunctionTypeNode): boolean;
+        /**
+         * The `[T * N]` half of signature support, kept separate so that a refusal
+         * can **stop** the function rather than merely be reported.
+         *
+         * `checkSignatureSupported` reports and compilation carries on — the right
+         * shape for a feature gate, whose codegen path can still produce a module.
+         * Not for this one: a value-form `[T * N]` parameter or return has no slot, so
+         * continuing reaches `Signature#paramRefs` / `#resultRefs`, which call
+         * `toRef`, which asserts for the value form by design. Measured before this
+         * split: `export function f(a: [u32 * 4]): u32` and
+         * `export function f(p: usize): [u32 * 4]` both crashed the compiler inside
+         * `toRef` instead of reporting.
+         */
+        private checkFixedArrayStorageInSignature;
+        /**
+         * Refuses a `[T * N]` that has no storage in the position it was written in.
+         *
+         * Landing 5a.5 made the memory model part of the Type, which splits the kind
+         * into three: the **view** (`@unmanaged [T * N]`, one address — works
+         * everywhere `@unmanaged T` works), the **heap** form (`@managed [T * N]`,
+         * Landing 5c) and the **value** form (`[T * N]`, `u32[N]`, `@inline [T * N]`
+         * — N inline elements, no address of its own).
+         *
+         * The value form exists and is laid out correctly: it is a record field's
+         * type, `sizeof` counts N × sizeof(T), and Landing 1's fixtures assert all of
+         * that. What it does not have is a **slot**. `toRef` asserts for it by design,
+         * so every position that needs a WASM local, parameter or result must be
+         * refused *before* that assert is reached — otherwise the compiler crashes
+         * where the answer is a diagnostic. Landing 5b gives the form inline storage
+         * (stack slot, copy at the ABI, sret) and these refusals come out.
+         *
+         * This mirrors `Program.checkInlineStructValue`, which refuses the same class
+         * of position for the same reason (a value with no address where one is
+         * needed). `position` names the site so the message says which case was hit.
+         */
+        private checkFixedArrayStoragePosition;
         /** Is `type` an `@inline struct`: a value carried as its fields, never as a
          *  pointer? */
         /**
@@ -6528,6 +6713,23 @@ declare module "types:tensionscript/src/compiler" {
          * there is no address to pass. Anything else refuses by name rather than
          * compiling a pointer.
          */
+        /**
+         * Expands a value-form `[T * N]` argument into one operand per element leaf.
+         *
+         * Two shapes reach here, and they differ in where the leaves come from:
+         *
+         * - **A value-form local** — push its SROA leaves. `pushSroaLeafOperands`
+         *   walks the map depth first through placeholders, which is exactly the
+         *   element-major order `paramRefs` declares.
+         * - **An array literal** — compile each element into its own operand. A record
+         *   element is several leaves and no literal names them (`{x, y}` goes through
+         *   the class path and *allocates*), so it is refused by name, matching
+         *   `fillSroaArrayFromLiteral`.
+         *
+         * Anything else — a call returning an array, a conditional — would need the
+         * value materialised somewhere, which is the return path, not this one.
+         */
+        private expandSroaArrayArgument;
         private expandSroaArgument;
         /**
          * The SROA local an expression names, or `null`.
@@ -6814,6 +7016,165 @@ declare module "types:tensionscript/src/compiler" {
          * has already reported why), and the caller has been told.
          */
         emitSroaStores(type: Type, fieldLocals: Map<string, Local>, dest: ExpressionRef, baseOffset: number, stmts: ExpressionRef[]): void;
+        /**
+         * Whether `type` is a fixed array in its **value** form — N inline elements,
+         * no address of its own — as opposed to the `@unmanaged` view (a pointer,
+         * Landing 5a.5) or the `@managed` heap form (Landing 5c).
+         */
+        isValueFormFixedArray(type: Type): boolean;
+        /**
+         * The largest `N` whose value-form array can be indexed with a **runtime**
+         * index.
+         *
+         * A runtime index on SROA leaves has no address to scale, so the element is
+         * selected with a `br_table` over one block per element. Past a handful of
+         * blocks that dispatch costs more than the thing it replaces: the caller who
+         * wants an arbitrary index over many elements wants a pointer, and
+         * `@unmanaged [T * N]` gives them one with no block at all. Eight is the
+         * boundary between the two. Landing 5d's spill strategy is what would lift it.
+         */
+        private static readonly VALUE_ARRAY_MAX_RUNTIME_INDEX;
+        /** Per-emission counter for the runtime-index block labels, so two accesses in
+         *  one function cannot collide (Binaryen requires unique block names). */
+        private sroaSelectId;
+        /**
+         * Fills `into` with one entry per **element** of a value-form `[T * N]`.
+         *
+         * The same shape `fillSroaFieldLocals` gives a record, with the index where
+         * the field name would be: the map is string-keyed and `"0"`, `"1"` are
+         * ordinary keys, so no new container is needed — only a new way to enumerate
+         * the entries.
+         *
+         * - A **scalar** element gets one WASM local, named `<path>$<index>`.
+         * - A **record** element is several leaves, so it gets the placeholder local
+         *   (`index -1`) carrying a nested map — exactly what a nested `@inline`
+         *   field gets, and for the same reason: `arr[i]` on a record names a whole
+         *   sub-value that no single local can hold, while `arr[i].x` descends one
+         *   hop to a leaf.
+         *
+         * Returns `false` when an element was refused, having reported why.
+         */
+        private fillSroaArrayLocals;
+        /**
+         * Compiles a value-form `[T * N]` local as SROA: one WASM local per element
+         * leaf, no local for the array itself, no store for the zero case.
+         *
+         * Returns `true` when the declaration was handled here (the caller must not
+         * fall through to the ordinary local path).
+         */
+        private compileSroaValueArrayLocal;
+        /**
+         * 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.
+         */
+        private fillSroaArrayFromLiteral;
+        /**
+         * The local behind `name`, when that local is a value-form `[T * N]` — i.e. a
+         * value stored as one WASM local per element leaf, with no slot of its own.
+         *
+         * Returns `null` for everything else, including the view form (which *is* an
+         * address and goes through the ordinary path).
+         */
+        private resolveSroaValueArray;
+        /**
+         * The compile-time value of an index expression, or `-1` when it is not a
+         * non-negative integer literal.
+         *
+         * `-1` is the "not constant" answer rather than an error: a runtime index is a
+         * legitimate access, it just takes the `br_table` path.
+         */
+        private constantIndexValue;
+        /**
+         * Indexes a value-form `[T * N]` local, whose elements are separate WASM
+         * locals.
+         *
+         * A **constant** index needs no dispatch at all: it names one leaf, and the
+         * access is `local.get` / `local.set` on it. A **runtime** index has no address
+         * to scale, so it is selected with a `br_table` over one block per element —
+         * bounded by {@link VALUE_ARRAY_MAX_RUNTIME_INDEX}, past which the caller wants
+         * a pointer view instead.
+         */
+        private compileSroaValueArrayElementAccess;
+        /**
+         * Selects one element leaf of a value-form array by a runtime index.
+         *
+         * The shape is one `br_table` with a block per element, each block yielding
+         * that element's leaf — the only way to choose between WASM locals at runtime,
+         * since they are not addressable. An index outside `[0, N)` is the caller's
+         * error, exactly as it is for `[T *]`: the extent is compile-time and there is
+         * no length on the value stack to check against.
+         */
+        private compileSroaValueArrayRuntimeIndex;
+        /**
+         * Reads `arr[i].field` where `arr` is a value-form array **of records** and `i`
+         * is a runtime index. Returns `0` when the shape does not apply.
+         *
+         * A record element is several leaves per candidate, so a single-value
+         * `br_table` cannot select one — but a *field* is one leaf per candidate, so
+         * the selection is per leaf: one block per element, each yielding that
+         * element's `<field>` leaf. Same block nesting as the scalar runtime index
+         * (`compileSroaValueArrayRuntimeIndex`), one hop lower.
+         *
+         * This is the shape the collision solver writes by hand today —
+         * `arr[i].x` with a runtime `i` over a run of records — which is why it is
+         * worth the dispatch rather than only supporting a constant index.
+         */
+        private compileSroaArrayLeafByRuntimeIndex;
+        /**
+         * Writes `arr[i].field = value` where `arr` is a value-form array of records
+         * and `i` is a runtime index. Returns `0` when the shape does not apply.
+         *
+         * The mirror of {@link compileSroaArrayLeafByRuntimeIndex}: one block per
+         * element, each storing into that element's `<field>` leaf. The value is
+         * materialised into a temp first — one WASM node cannot be the parent of N
+         * stores — which is the same reason the scalar runtime-index write does it.
+         */
+        private compileSroaArrayLeafStoreByRuntimeIndex;
+        /**
+         * Emits the `br_table` that selects one of `leafIndices` by a runtime index.
+         *
+         * The only way to choose between WASM locals at runtime, since locals are not
+         * addressable: one block per candidate, the body sitting **after** its block's
+         * `end` (where a branch target lands), element 0 as the fall-through.
+         *
+         * One helper rather than four. After Landing 5b.1 four call sites emitted this
+         * same nesting — scalar read, scalar write, record-field read, record-field
+         * write — differing only in which leaf each block touched. Params and returns
+         * would have added more, and a structural bug in one of them would have been
+         * invisible in the other three.
+         *
+         * **A method, not a closure.** The self-hosted compiler refuses an arrow
+         * function that captures a local without a declared type — `AS100: a captured
+         * local without a declared type (closures lowering)` — so the four sites
+         * cannot share a callback.
+         *
+         * `storeValueLocal` is `-1` for a read; for a store it names the temp holding
+         * the value. A store's body cannot reuse the caller's expression tree: a WASM
+         * node has one parent, so N stores cannot share one subtree. `resultType` is
+         * `TypeRef.None` for a store, in which case the dispatch yields nothing.
+         */
+        private compileLeafIndexSelect;
+        /**
+         * 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.
+         *
+         * Requires `Feature.MultiValue`, which `Resolver` turns on when it resolves
+         * this return type (`enableMultiValueOnce`), so a module that returns one of
+         * these always has the feature and a module that does not never does.
+         */
+        private compileMultivalueReturnStatement;
         private compileSroaLocal;
         /**
          * The instance fields of an `@inline struct`, in declaration order, or `null`