@yabgu_gm/tensionscript 0.11.0 → 0.11.2

package/dist/assemblyscript.generated.d.ts

@@ -620,7 +620,9 @@ declare module "types:tensionscript/src/diagnosticMessages.generated" {
         _abi_align_0_the_alignment_must_be_a_power_of_two = 6407,
         _abi_align_0_is_less_than_the_field_type_s_natural_alignment_1_asking_for_less_is_a_lie_so_it_is_refused_rather_than_silently_ignored = 6408,
         _abi_align_0_is_too_large_the_maximum_is_1 = 6409,
-        Alignment_is_a_property_of_the_field_not_its_type_Place_abi_align_N_on_the_field_declaration = 6410
+        Alignment_is_a_property_of_the_field_not_its_type_Place_abi_align_N_on_the_field_declaration = 6410,
+        A_view_parameter_unmanaged_0_over_an_inline_type_cannot_appear_in_a_host_visible_signature_an_external_or_exported_parameter_is_supplied_by_the_host_and_a_view_is_an_address_this_compiler_did_not_materialise = 6411,
+        Call_to_0_emits_1_operands_but_its_signature_declares_2 = 6412
     }
     /** Translates a diagnostic code to its respective string. */
     export function diagnosticCodeToString(code: DiagnosticCode): string;
@@ -2706,6 +2708,21 @@ declare module "types:tensionscript/src/types" {
          * all of them.
          */
         static wasmParamCountOf(type: Type): number;
+        /**
+         * Appends the **leaf** types of an `@inline struct`, in declaration order,
+         * depth first.
+         *
+         * A leaf is a field that occupies one WASM local: a scalar or a reference. A
+         * field whose type is itself an `@inline struct` is not a leaf — it is several
+         * locals behind a map — so the walk recurses into it. This is the type-level
+         * twin of the `fieldLocals` tree the compiler builds
+         * (`Compiler#fillSroaFieldLocals`), and the two must agree in **order** as
+         * well as count: the callee binds WASM parameter *k* to the *k*th leaf, and
+         * the caller pushes operands in the same walk.
+         */
+        static leafTypesOf(type: Type, out: Type[]): void;
+        /** The number of leaf locals an `@inline struct` occupies. */
+        static leafCountOf(type: Type): number;
         /**
          * How many WASM operands **this signature** spends on source parameter
          * `sourceIndex`.
@@ -2722,6 +2739,18 @@ declare module "types:tensionscript/src/types" {
          * the same source parameter.
          */
         wasmParamSlotCountOf(sourceIndex: number): number;
+        /**
+         * Whether source parameter `sourceIndex` is a **view**: `@unmanaged` at the
+         * declaration over a type that is an `@inline struct`.
+         *
+         * The type still says *value* — every use of `MyStruct` shares one `Type`, and
+         * that is what makes a member lookup work on the parameter — while the model
+         * says this use is an address. One `i32` slot, no field locals, a load at the
+         * field's offset: the same crossing an `@unmanaged struct` parameter already
+         * takes, with the model recorded at the declaration instead of on a pointer
+         * type.
+         */
+        isViewParam(sourceIndex: number): boolean;
         /**
          * Whether source parameter `sourceIndex` **crosses by value** — one `i32`
          * address instead of one WASM operand per field.
@@ -2735,8 +2764,12 @@ declare module "types:tensionscript/src/types" {
          *   address, and the override asks for a copy of what is there — the same
          *   copy, read from memory instead of from SROA locals.
          *
-         * The reverse is not a thing: `@unmanaged`/`@managed` over an `@inline`
-         * declaration is refused (`TS6395`), because a value has no address to lend.
+         * The reverse is partly a thing now. `@unmanaged` over an `@inline`
+         * declaration is legal where the use supplies an address — a parameter (a
+         * view parameter, `isViewParam`) or `changetype`'s type argument — and a view
+         * parameter crosses as a pointer, so it is asked before this predicate. Every
+         * other cell still refuses (`TS6395`), and `@managed` over `@inline` refuses
+         * at every position: a value has no GC header and no address to lend.
          */
         crossesByValueParam(sourceIndex: number): boolean;
         /**
@@ -2759,9 +2792,17 @@ declare module "types:tensionscript/src/types" {
         get byValPointerParams(): boolean;
         /** Whether `type` is an `@inline struct`. */
         static isInlineStructRef(type: Type): boolean;
-        /** The number of fields an `@inline struct` has (0 for a record with none).
-         *  Distinct from `wasmParamCountOf`, which cannot express "one field" and
-         *  "one operand" differently. */
+        /**
+         * How many **WASM slots** an `@inline struct` spends — its leaf count.
+         *
+         * Leaf count, not direct-field count: a nested inline field is several locals,
+         * so `Outer1 { a: u32; inner: Inner{x,y} }` is 3, not 2. A record with no
+         * members is 0.
+         *
+         * Callers that made sense of "direct fields" are listed in the Phase C audit
+         * (`docs`); the one place that genuinely needs the direct count is layout, and
+         * layout reads `members` itself rather than asking this.
+         */
         static fieldCountOf(type: Type): number;
         /**
          * Whether a call to this signature passes a hidden destination pointer.
@@ -3095,6 +3136,60 @@ declare module "types:tensionscript/src/resolver" {
         currentElementExpression: Expression | null;
         /** Whether a new override has been discovered. */
         discoveredOverride: boolean;
+        /**
+         * Whether a use-site `@unmanaged` over an `@inline` declaration is being
+         * resolved as the **type argument of `changetype`**.
+         *
+         * That position is the one where the operand can supply the address the value
+         * itself does not have, so the refusal's premise does not hold there (see
+         * `checkMemoryModelOverride`). Every other position — a parameter, a local, a
+         * field, a return type — still refuses with `TS6395`, which is what keeps the
+         * function-parameter form (`Phase 2`) out of this change.
+         *
+         * The compiler sets this around the one `resolveTypeArguments` call it makes
+         * for a `changetype` builtin (`Compiler#compileCallExpressionBuiltin`), and
+         * resets it immediately: the flag is a scope, not a mode.
+         */
+        allowInlineView: boolean;
+        /**
+         * Whether a use-site `@unmanaged` over an `@inline` declaration is being
+         * resolved in a **parameter position** — the cell where the caller supplies
+         * the address, so `f(a: @unmanaged T)` with an inline `T` is a view parameter.
+         *
+         * Distinct from {@link allowInlineView} (Phase 1, `changetype`'s type
+         * argument, where the operand supplies the address at the point of use).
+         *
+         * **Saved and restored, never blindly cleared.** Resolving one parameter's
+         * type can resolve another function (a default value's call, a nested
+         * signature), and a nested window that reset the flag to `false` on the way
+         * out closed the outer window — measured: the owner's pattern reported TS6395
+         * with both flags reading `false` while inside `resolveFunction`'s own loop.
+         */
+        allowInlineViewParam: boolean;
+        /**
+         * Call expressions that are **views of caller bytes**: an inline-typed
+         * `changetype<@unmanaged T>(ptr)`.
+         *
+         * Marked here, at resolution, because the compiler asks this question while
+         * compiling the *field access* — which happens before the `changetype` it
+         * wraps is ever compiled. Recording it at codegen time (the first attempt)
+         * produced a field read that never saw the mark and compiled to
+         * `unreachable`.
+         *
+         * Keyed on the AST node rather than on the type, because the type is the
+         * declaration's (`T` is still an `@inline struct`) and the model is the
+         * *use's*: there is one `Type` per class, shared by every use.
+         */
+        private viewCalls;
+        /**
+         * Records `node` as a view call. The resolver marks the ones it resolves;
+         * `Compiler#compileCallExpressionBuiltin` marks the ones it resolves itself,
+         * because a builtin's type arguments are resolved on the *codegen* path and
+         * never pass through `maybeInferCall`.
+         */
+        markViewCall(node: Expression): void;
+        /** Whether `node` is an inline-typed `changetype<@unmanaged T>(...)`. */
+        isViewCall(node: Expression): boolean;
         /** Constructs the resolver for the specified program. */
         constructor(
         /** The program to construct a resolver for. */
@@ -3122,10 +3217,14 @@ declare module "types:tensionscript/src/resolver" {
          * - **`@managed` over an `@unmanaged` declaration** — the collector traces a
          *   reference through a header the record does not have. No emitter can
          *   invent the header, so a use cannot confer provenance. (`TS6394`.)
-         * - **`@unmanaged`/`@managed` over an `@inline` declaration** — a value is
-         *   stored as one local per field and has **no address** at all, so there is
-         *   nothing to lend as a pointer and nothing a header could sit in front of.
-         *   (`TS6395`.)
+         * - **`@managed` over an `@inline` declaration** — a value has neither a
+         *   header nor an address, at any position. (`TS6395`.)
+         * - **`@unmanaged` over an `@inline` declaration**, *except* where the use
+         *   supplies an address: `changetype`'s type argument (the operand supplies
+         *   it) and a parameter (the caller supplies it). Those two windows are
+         *   `allowInlineView` and `allowInlineViewParam`, and they are the whole
+         *   difference between a view and a claim. Every other position — a return
+         *   type, a local, a field — still has nothing to lend. (`TS6395`.)
          *
          * Everything else is left to the emitters: `@unmanaged` over `@managed` is
          * the identity cell (10.0a), `@inline` over a pointer declaration is the
@@ -3763,6 +3862,14 @@ declare module "types:tensionscript/src/program" {
         function fromUnaryPostfixToken(token: Token): OperatorKind;
     }
     /** Represents an AssemblyScript program. */
+    /** How many WASM slots a parameter binding consumed — see
+     *  `Program#bindSroaParameterLeaves`. A one-field wrapper because this compiler
+     *  reports the count and the caller advances past it; a bare `i32` return would
+     *  be the same information with no name at the call site. */
+    export class BindResult {
+        leafCount: number;
+        constructor(leafCount: number);
+    }
     export class Program extends DiagnosticEmitter {
         /** Compiler options. */
         options: Options;
@@ -4479,6 +4586,17 @@ declare module "types:tensionscript/src/program" {
          * therefore cannot alias.
          */
         fieldLocals: Map<string, Local> | null;
+        /**
+         * Whether this local is a **view parameter**: `a: @unmanaged T` where `T` is
+         * an inline type.
+         *
+         * Its `type` is still the inline record, because that is what makes `a.field`
+         * resolve — every use of `T` shares one `Type`. Its *storage* is the one `i32`
+         * WASM parameter holding the caller's address, which is why a field read goes
+         * through `load` at the field's offset rather than through `fieldLocals`
+         * (there are none: a view has no per-field locals to copy into).
+         */
+        isViewParam: boolean;
         /** Constructs a new local variable. */
         constructor(
         /** Simple name. */
@@ -4590,6 +4708,20 @@ declare module "types:tensionscript/src/program" {
         nextInlineId: number;
         /** Counting id of anonymous inner functions. */
         nextAnonymousId: number;
+        /**
+         * Binds an `@inline struct` parameter's **leaves** to the WASM parameters that
+         * carry them, building the `fieldLocals` tree a read path walks.
+         *
+         * `localIndex` is the index of the parameter's first WASM slot; the walk
+         * consumes one slot per leaf in the same depth-first order
+         * `Signature.leafTypesOf` declares and the caller pushes operands in. Returns
+         * how many slots were consumed, so the caller advances past them.
+         *
+         * A nested field gets a placeholder `Local` (index `-1`) carrying its own map,
+         * exactly as `fillSroaFieldLocals` builds one for a local — the tree shape is
+         * one structure regardless of where the leaves' storage came from.
+         */
+        bindSroaParameterLeaves(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>`. */
@@ -5284,7 +5416,7 @@ declare module "types:tensionscript/src/compiler" {
     import { Range, DiagnosticEmitter } from "types:tensionscript/src/diagnostics";
     import { Module, MemorySegment, ExpressionRef, TypeRef, GlobalRef } from "types:tensionscript/src/module";
     import { Feature, Target, Runtime } from "types:tensionscript/src/common";
-    import { Program, Class, Element, DeclaredElement, Enum, Function, Global, Property, VariableLikeElement, File } from "types:tensionscript/src/program";
+    import { Program, Class, Element, DeclaredElement, Enum, Function, Global, Local, Property, VariableLikeElement, File } from "types:tensionscript/src/program";
     import { Flow, ConditionKind } from "types:tensionscript/src/flow";
     import { Resolver } from "types:tensionscript/src/resolver";
     import { Node, FunctionTypeNode, Statement, Expression } from "types:tensionscript/src/ast";
@@ -5770,6 +5902,18 @@ declare module "types:tensionscript/src/compiler" {
         private needToStack;
         /** Marks managed call operands for the shadow stack. */
         private operandsTostack;
+        /**
+         * Checks that the operands about to be passed match the WASM arity the callee
+         * declares, and reports a clean diagnostic when they do not.
+         *
+         * The invariant is maintained by the default-argument filling in
+         * `makeCallDirect`; this guard exists because when that filling misses — as it
+         * did for an sret callee with an omitted optional argument — the mismatch
+         * reached the WASM validator as `call* param number must match`, which names a
+         * binaryen rule and never mentions the call that broke it. A wrong arity is a
+         * compiler bug, so it should say so at the call site.
+         */
+        private checkCallArity;
         /** Creates a direct call to the specified function. */
         makeCallDirect(instance: Function, operands: ExpressionRef[] | null, reportNode: Node, immediatelyDropped?: boolean): ExpressionRef;
         /** Compiles an indirect call to a first-class function. */
@@ -5947,11 +6091,27 @@ declare module "types:tensionscript/src/compiler" {
         /**
          * The SROA local an expression names, or `null`.
          *
-         * Only a bare identifier can be one: `p.x.y` where `x` is itself an inline
-         * struct cannot happen this phase (a nested field is refused at declaration),
-         * so the receiver of a field access is either an SROA local or an ordinary
-         * expression that has an address.
+         * The receiver is either an SROA local (base identifier) or a chain of field
+         * accesses into one (`o.inner` in `o.inner.x`). The chain is walked from the
+         * base outward, one hop per `fieldLocals` lookup: a nested inline field is
+         * entered through the placeholder `Local` its creation installed
+         * (`fillSroaFieldLocals`), so the walk and the tree are one structure rather
+         * than two that could disagree.
+         *
+         * Returns the `Local` the final hop resolved to, or `null` when any step does
+         * not hold — a non-local base, a field with no entry, or a leaf reached before
+         * the chain ends. `null` is not an error here: the caller falls through to the
+         * ordinary address paths, which refuse a value with no address.
          */
+        /**
+         * Pushes one operand per **leaf** of a `fieldLocals` tree, depth first.
+         *
+         * Shared by the call site (`expandSroaArgument`) so the operand order is the
+         * one `Signature.leafTypesOf` declares and the binder indexes into — three
+         * walks, one order. A nested field's entry is a placeholder (index `-1`)
+         * carrying its own map, so the walk descends through it.
+         */
+        private pushSroaLeafOperands;
         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`);
@@ -6041,6 +6201,15 @@ declare module "types:tensionscript/src/compiler" {
         /** `base + mark + extra`, freshly built. Callers must not share the node:
          *  Binaryen's passes assume a single parent per expression. */
         private makeSretAddressPlus;
+        /**
+         * Stores a by-value argument's leaves into the static call-temp region.
+         *
+         * The same tree walk as `copyInto` (`emitSroaStores`) and `copySroaValue`:
+         * leaves become stores at `tempAddress + field offset`, a nested field is
+         * descended into. Keeping one recursion is what makes a nested value cross a
+         * host boundary at the layout the C side expects.
+         */
+        emitTempArgumentLeaves(type: Type, fieldLocals: Map<string, Local>, base: number, markLocal: Local, baseOffset: number, stmts: ExpressionRef[]): void;
         /**
          * Materialises one `@inline struct` argument of an `@external` call on the
          * static call-temp stack and returns the address to pass.
@@ -6111,6 +6280,93 @@ declare module "types:tensionscript/src/compiler" {
          * Returns true when the declaration was handled here (the caller must not fall
          * through to the ordinary local path).
          */
+        /**
+         * Fills `into` with one entry per field of an `@inline struct` value.
+         *
+         * A **leaf** field (scalar, or a reference) gets one WASM local, named
+         * `<path>$<field>` — a synthetic name keeps it out of user scope, so nothing
+         * can look one up by accident.
+         *
+         * A field whose type is itself an `@inline struct` is **not a leaf**: it is
+         * recursed into, and its entry is a placeholder `Local` (index `-1`) carrying
+         * its own map. That makes `fieldLocals` a **tree** whose shape is the value's
+         * nesting, which is what lets a read path walk `o.inner.x` a hop at a time
+         * without a second representation. The placeholder is never `local.get`-ed:
+         * the bare-read guard refuses a value read and the receiver walk descends to
+         * a leaf before emitting anything.
+         *
+         * Returns `false` when a field was refused, having reported why. The refusal
+         * is per **leaf**, so a nested value inherits exactly the rules the flat one
+         * has — a `T[N]` field or a GC-reference field is refused at any depth.
+         */
+        private fillSroaFieldLocals;
+        /**
+         * Copies one SROA value's leaves into another's, following the tree.
+         *
+         * `from` and `to` are the two `fieldLocals` maps — the same shape
+         * `fillSroaFieldLocals` builds, so a nested field is a placeholder on both
+         * sides and the recursion descends through it rather than trying to move a
+         * value that has no single representation.
+         *
+         * This is what makes `let q = p` and `q = p` **copies** rather than aliases:
+         * one `local.set` per leaf, so a later write to `q` cannot be seen through
+         * `p`. Both sides come from this compiler's own maps, so there is no aliasing
+         * question to answer — the leaves are distinct locals by construction.
+         */
+        private copySroaValue;
+        /**
+         * Stores a `fieldLocals` tree's leaves into the hidden destination slot at
+         * `destIndex`, one store per leaf.
+         *
+         * The third destination shape for the same recursion: `emitSroaStores` writes
+         * to a compiled `usize`, `emitTempArgumentLeaves` to a call-temp address, and
+         * this one to a **parameter** — the sret slot a `return p` fills. The address
+         * is a fresh `local.get` per store, because Binaryen's passes assume one
+         * parent per node.
+         */
+        emitSroaStoresToLocal(type: Type, fieldLocals: Map<string, Local>, destIndex: number, baseOffset: number, stmts: ExpressionRef[]): void;
+        /**
+         * Zeroes every **leaf** of an `@inline struct` in the destination slot.
+         *
+         * `return new P()` has no local to copy from — the value is all zeroes — but
+         * the slot is stack space that a previous sret call may have filled, so the
+         * bytes still have to be written. Walking the type rather than the direct
+         * fields is what zeroes a nested field's leaves: measured before this,
+         * `return new Outer1()` with `Inner{x,y}` stored only offset 0 and left
+         * offsets 4 and 8 holding whatever was there.
+         */
+        emitSroaZerosToLocal(type: Type, destIndex: number, baseOffset: number, stmts: ExpressionRef[]): void;
+        /**
+         * Loads an `@inline struct`'s leaves out of the sret slot into a target's
+         * field locals, one load per leaf.
+         *
+         * The mirror of {@link emitSroaStoresToLocal}: `let q = make()` reads the slot
+         * back into the leaf locals a read path walks. A fresh slot address per load,
+         * for the same one-parent-per-node reason.
+         */
+        emitSretLoadsInto(type: Type, fieldLocals: Map<string, Local>, base: number, markLocal: Local, baseOffset: number, stmts: ExpressionRef[]): void;
+        /**
+         * The `fieldLocals` tree behind an SROA-tracked expression, or `null`.
+         *
+         * The public face of {@link resolveSroaReceiver} for code outside this class —
+         * today only the `copyInto` builtin, which needs the *tree* (to store its
+         * leaves) rather than a single receiver.
+         */
+        sroaTreeOf(expression: Expression): Map<string, Local> | null;
+        /**
+         * Stores an inline value's leaves at `dest + offset`.
+         *
+         * The third leaf consumer, beside `copySroaValue` (local-to-local) and the
+         * read path (local-to-stack): same tree, same recursion, an expression
+         * reference instead of a destination map. The offsets come from the **type**
+         * (`property.memoryOffset`, the layout the C side sees), so what lands in
+         * memory is the wire layout, not a packing of the locals.
+         *
+         * Leaves whose local is missing are skipped rather than stored as `-1`: a
+         * field refused at declaration was never part of the value (`isSroaFieldType`
+         * has already reported why), and the caller has been told.
+         */
+        emitSroaStores(type: Type, fieldLocals: Map<string, Local>, dest: ExpressionRef, baseOffset: number, stmts: ExpressionRef[]): void;
         private compileSroaLocal;
         /**
          * The instance fields of an `@inline struct`, in declaration order, or `null`
@@ -6296,6 +6552,7 @@ declare module "types:tensionscript/src/builtins" {
         const select = "~lib/builtins/select";
         const unreachable = "~lib/builtins/unreachable";
         const changetype = "~lib/builtins/changetype";
+        const copyInto = "~lib/builtins/copyInto";
         const assert = "~lib/builtins/assert";
         const call_indirect = "~lib/builtins/call_indirect";
         const unchecked = "~lib/builtins/unchecked";