@yabgu_gm/tensionscript 0.11.2 → 0.11.4

package/dist/assemblyscript.generated.d.ts

@@ -4597,6 +4597,16 @@ declare module "types:tensionscript/src/program" {
          * (there are none: a view has no per-field locals to copy into).
          */
         isViewParam: boolean;
+        /**
+         * Whether this local is a **view local**: `const p = changetype<@unmanaged T>(ptr)`
+         * where `T` is an inline type.
+         *
+         * The same idea as {@link isViewParam} — the local holds an address, not a
+         * value — but a body local rather than a parameter. `type` stays the record
+         * type, because that is what makes `p.field` resolve; `getNonParameterLocalTypes`
+         * is what gives it one `i32` slot instead of the record's reference type.
+         */
+        isViewLocal: boolean;
         /** Constructs a new local variable. */
         constructor(
         /** Simple name. */
@@ -6063,7 +6073,35 @@ declare module "types:tensionscript/src/compiler" {
         checkSignatureSupported(signature: Signature, reportNode: FunctionTypeNode): boolean;
         /** Is `type` an `@inline struct`: a value carried as its fields, never as a
          *  pointer? */
+        /**
+         * Whether `node` is syntactically `changetype<@unmanaged T>(...)`.
+         *
+         * The resolver's `isViewCall` is authoritative once the call has been
+         * compiled, but `compileSroaLocal` decides *before* compiling the initialiser,
+         * so it has to read the shape off the AST. The two agree: the mark is set
+         * from exactly this test (`compileCallExpressionBuiltin`).
+         */
+        private isUnmanagedChangetype;
         private isInlineStructType;
+        /**
+         * Reads `field` through a view of the record's bytes at `basePtr`.
+         *
+         * A scalar field is a load at its offset. A field whose type is itself an
+         * `@inline struct` is **not** a load: the field is bytes inside the viewed
+         * record, so what the caller needs is their *address* — `basePtr + offset` —
+         * the same shape the declared-`@unmanaged` path produces through the
+         * inline-field branch of `compilePropertyAccess`, and the same `i32` a
+         * record accessor takes as `this`.
+         *
+         * Loading it instead was a silent miscompile: a 4-byte load of the field's
+         * first bytes was handed to the inner setter as if it were a pointer.
+         * Measured — `changetype<@unmanaged R>(ptr).pos.x = v` read a float's bit
+         * pattern as an address and trapped with `memory access out of bounds`.
+         *
+         * A fixed-array field is storage for the same reason, so it takes the address
+         * branch too.
+         */
+        private viewFieldAccess;
         /** The WASM result type of a value of `type`: `None` for an `@inline struct`,
          *  whose value is written to the caller's slot instead of returned. Calling
          *  `type.toRef()` on an inline struct is what this replaces — it has no
@@ -6177,8 +6215,14 @@ declare module "types:tensionscript/src/compiler" {
         /** The bytes one call-temp slot needs for `type`, rounded up to the region's
          *  16-byte alignment so every slot stays aligned for any field. */
         private sretSizeOf;
-        /** `base + mark`, freshly built. Callers must not share the node: Binaryen
-         *  passes assume a single parent per expression. */
+        /** The call-temp slot address: the mark alone, freshly built so callers never
+         *  share a node (Binaryen's passes assume a single parent per expression).
+         *
+         *  **Not `base + mark`.** `ensureSretStack` initialises the bump global to
+         *  `base`, so a mark saved from it is already absolute — which is also what
+         *  `makeSretGuard` assumes when it tests `mark + size > base + SIZE`. Adding
+         *  `base` a second time yields `2 * base + ...`; measured, that produced a
+         *  fault at exactly `0x1002a60 = 2 * 0x801418`. */
         private makeSretAddress;
         /** A load of one field of an `@inline struct` at a slot address. */
         private makeSretFieldLoad;
@@ -6198,7 +6242,7 @@ declare module "types:tensionscript/src/compiler" {
          * the caller's later mutation of the struct cannot be observed by the body.
          */
         private emitExportByValPrologue;
-        /** `base + mark + extra`, freshly built. Callers must not share the node:
+        /** `mark + extra`, freshly built. Callers must not share the node:
          *  Binaryen's passes assume a single parent per expression. */
         private makeSretAddressPlus;
         /**
@@ -6209,7 +6253,7 @@ declare module "types:tensionscript/src/compiler" {
          * 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;
+        emitTempArgumentLeaves(type: Type, fieldLocals: Map<string, Local>, 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.
@@ -6344,7 +6388,7 @@ declare module "types:tensionscript/src/compiler" {
          * 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;
+        emitSretLoadsInto(type: Type, fieldLocals: Map<string, Local>, markLocal: Local, baseOffset: number, stmts: ExpressionRef[]): void;
         /**
          * The `fieldLocals` tree behind an SROA-tracked expression, or `null`.
          *