@yabgu_gm/tensionscript 0.11.1 → 0.11.3

package/dist/assemblyscript.generated.d.ts

@@ -621,7 +621,8 @@ declare module "types:tensionscript/src/diagnosticMessages.generated" {
         _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,
-        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
+        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;
@@ -4596,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. */
@@ -5901,6 +5912,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. */
@@ -6050,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