fix: finish subtype-aware StaticArray deserialization

Author: JairusSW

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+### fix: finish subtype-aware StaticArray deserialization
+- Reworked `StaticArray` deserialization to dispatch by element subtype, mirroring the existing `Array<subtype>` deserializer matrix instead of relying on a generic fallback.
+- Materialized complex deserialized array results into fixed `StaticArray` storage for nested arrays, nested static arrays, maps, `JSON.Value`, `JSON.Box`, `JSON.Obj`, `JSON.Raw`, and transform-backed structs.
+- Added regression coverage for richer `StaticArray` payloads and fixed a shared `JSON.Raw[]` delimiter edge case exposed by the new `StaticArray<JSON.Raw>` path.
+
 ### fix: tighten default-path runtime correctness
 - Fixed `JSON.Value` signed integer tagging and stringification so negative integer values no longer serialize as unsigned.
 - Fixed `@omitif("...")` to use the same omit semantics as the callback form during transform-generated serialization.

assembly/__tests__/staticarray.spec.ts

@@ -167,6 +167,48 @@ describe("Should round-trip static array objects with reordered fields", () => {
   expect(JSON.stringify(arr)).toBe('[{"x":1.0,"y":2.0,"z":3.0},{"x":4.0,"y":5.0,"z":6.0}]');
 });
 
+describe("Should deserialize static arrays of JSON.Value", () => {
+  const arr = JSON.parse<StaticArray<JSON.Value>>('[{"a":1},"x",false,null,[1,2]]');
+  expect(arr.length).toBe(5);
+  expect(arr[0].get<JSON.Obj>().get("a")!.toString()).toBe("1.0");
+  expect(arr[1].get<string>()).toBe("x");
+  expect(arr[2].get<bool>().toString()).toBe("false");
+  expect(arr[3].type.toString()).toBe(JSON.Types.Null.toString());
+  expect(JSON.stringify(arr[4].get<JSON.Value[]>())).toBe("[1.0,2.0]");
+  expect(JSON.stringify(arr)).toBe('[{"a":1.0},"x",false,null,[1.0,2.0]]');
+});
+
+describe("Should deserialize static arrays of maps and boxed values", () => {
+  const maps = JSON.parse<StaticArray<Map<string, i32>>>('[{"a":1},{"b":2,"c":3}]');
+  const boxed = JSON.parse<StaticArray<JSON.Box<i32>>>("[1,-2,3]");
+
+  expect(maps.length).toBe(2);
+  expect(maps[0].get("a")).toBe(1);
+  expect(maps[1].get("b")).toBe(2);
+  expect(maps[1].get("c")).toBe(3);
+  expect(JSON.stringify(maps)).toBe('[{"a":1},{"b":2,"c":3}]');
+
+  expect(boxed.length).toBe(3);
+  expect(boxed[0].value).toBe(1);
+  expect(boxed[1].value).toBe(-2);
+  expect(boxed[2].value).toBe(3);
+  expect(JSON.stringify(boxed)).toBe("[1,-2,3]");
+});
+
+describe("Should preserve escaped nested strings inside static arrays", () => {
+  const strings = JSON.parse<StaticArray<string>>('["path \\\\\\\\ and quote \\\\\\"","brackets [ ] { }"]');
+  const raw = JSON.parse<StaticArray<JSON.Raw>>('["text with spaces","{\\"nested\\":[1,2,3]}"]');
+
+  expect(strings.length).toBe(2);
+  expect(strings[0]).toBe('path \\\\ and quote \\"');
+  expect(strings[1]).toBe("brackets [ ] { }");
+  expect(JSON.stringify(strings)).toBe('["path \\\\\\\\ and quote \\\\\\"","brackets [ ] { }"]');
+
+  expect(raw.length).toBe(2);
+  expect(raw[0].toString()).toBe('"text with spaces"');
+  expect(raw[1].toString()).toBe('"{\\"nested\\":[1,2,3]}"');
+});
+
 describe("Extended regression coverage - nested and escaped payloads", () => {
   expect(JSON.stringify(JSON.parse<i32>("0"))).toBe("0");
   expect(JSON.stringify(JSON.parse<bool>("true"))).toBe("true");

assembly/deserialize/simple/array/raw.ts

@@ -11,7 +11,9 @@ export function deserializeRawArray(srcStart: usize, srcEnd: usize, dst: usize):
   srcStart += 2;
   while (srcStart < srcEnd) {
     let code = load<u16>(srcStart);
-    if (code == COMMA || isSpace(code)) {
+    if (code == BRACKET_RIGHT) {
+      break;
+    } else if (code == COMMA || isSpace(code)) {
       srcStart += 2;
       continue;
     } else if (code == QUOTE) {

assembly/deserialize/simple/staticarray.ts

@@ -1,28 +1,71 @@
-import { deserializeStaticArrayInteger } from "./staticarray/integer";
-import { deserializeStaticArrayFloat } from "./staticarray/float";
+import { OBJECT, TOTAL_OVERHEAD } from "rt/common";
+import { JSON } from "../..";
+import { deserializeArbitraryArray } from "./array/arbitrary";
+import { deserializeArrayArray } from "./array/array";
+import { deserializeBooleanArray } from "./array/bool";
+import { deserializeBoxArray } from "./array/box";
+import { deserializeFloatArray } from "./array/float";
+import { deserializeIntegerArray } from "./array/integer";
+import { deserializeMapArray } from "./array/map";
+import { deserializeObjectArray } from "./array/object";
+import { deserializeRawArray } from "./array/raw";
+import { deserializeStructArray } from "./array/struct";
+import { deserializeStringArray } from "./array/string";
 import { deserializeStaticArrayBoolean } from "./staticarray/bool";
+import { deserializeStaticArrayFloat } from "./staticarray/float";
+import { deserializeStaticArrayInteger } from "./staticarray/integer";
 import { deserializeStaticArrayString } from "./staticarray/string";
-import { deserializeStaticArrayArray } from "./staticarray/array";
-import { deserializeStaticArrayStruct } from "./staticarray/struct";
+
+@inline function materializeStaticArray<T extends StaticArray<any>>(src: valueof<T>[], dst: usize): T {
+  const byteLength = (<usize>src.length) << alignof<valueof<T>>();
+  let out = dst;
+
+  if (!out) {
+    out = __new(byteLength, idof<T>());
+  } else if (changetype<OBJECT>(out - TOTAL_OVERHEAD).rtSize != byteLength) {
+    out = __renew(out, byteLength);
+  }
+
+  const typed = changetype<T>(out);
+  for (let i = 0; i < src.length; i++) {
+    unchecked((typed[i] = unchecked(src[i])));
+  }
+  return typed;
+}
 
 export function deserializeStaticArray<T extends StaticArray<any>>(srcStart: usize, srcEnd: usize, dst: usize): T {
   if (isString<valueof<T>>()) {
-    return <T>deserializeStaticArrayString(srcStart, srcEnd, dst);
+    return changetype<T>(deserializeStaticArrayString(srcStart, srcEnd, dst));
   } else if (isBoolean<valueof<T>>()) {
     return deserializeStaticArrayBoolean<T>(srcStart, srcEnd, dst);
   } else if (isInteger<valueof<T>>()) {
     return deserializeStaticArrayInteger<T>(srcStart, srcEnd, dst);
   } else if (isFloat<valueof<T>>()) {
     return deserializeStaticArrayFloat<T>(srcStart, srcEnd, dst);
-  } else if (isArrayLike<valueof<T>>()) {
-    return deserializeStaticArrayArray<T>(srcStart, srcEnd, dst);
+  } else if (isArray<valueof<T>>()) {
+    return materializeStaticArray<T>(deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
   } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
     const type = changetype<nonnull<valueof<T>>>(0);
-    if (isDefined(type.__DESERIALIZE)) {
-      return deserializeStaticArrayStruct<T>(srcStart, srcEnd, dst);
+    if (type instanceof StaticArray) {
+      return materializeStaticArray<T>(deserializeArrayArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+    } else if (type instanceof JSON.Value) {
+      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeArbitraryArray(srcStart, srcEnd, 0)), dst);
+    } else if (type instanceof JSON.Box) {
+      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeBoxArray<valueof<T>[]>(srcStart, srcEnd, 0)), dst);
+    } else if (type instanceof JSON.Obj) {
+      return materializeStaticArray<T>(deserializeObjectArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+    } else if (type instanceof JSON.Raw) {
+      return materializeStaticArray<T>(changetype<valueof<T>[]>(deserializeRawArray(srcStart, srcEnd, 0)), dst);
+    } else if (type instanceof Map) {
+      return materializeStaticArray<T>(deserializeMapArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+      // @ts-ignore: supplied by transform
+    } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+      return materializeStaticArray<T>(deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
+      // @ts-ignore: supplied by transform
+    } else if (isDefined(type.__DESERIALIZE)) {
+      return materializeStaticArray<T>(deserializeStructArray<valueof<T>[]>(srcStart, srcEnd, 0), dst);
     }
-    throw new Error("Could not parse static array of type " + nameof<T>() + "!");
-  } else {
-    throw new Error("Could not parse static array of type " + nameof<T>() + "!");
   }
+
+  throw new Error("Could not parse static array of type " + nameof<T>() + "!");
 }