@yabgu_gm/tensionscript 0.11.2 → 0.11.3

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