json-as 1.3.1 → 1.3.2

package/assembly/deserialize/swar/array/float.ts

@@ -1,10 +1,9 @@
-import { deserializeFloatField } from "../../float";
+import { deserializeFloatField } from "../../simple/float";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
 
-@inline export function deserializeFloatArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  const out = ensureArrayField<T>(fieldPtr);
+@inline export function deserializeFloatArrayInto<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
   let index = 0;
 
   do {
@@ -37,3 +36,8 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
   throw new Error("Failed to parse JSON!");
 }
+
+
+@inline export function deserializeFloatArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  return deserializeFloatArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+}

package/assembly/deserialize/swar/array/generic.ts

@@ -0,0 +1,40 @@
+import { JSON } from "../../..";
+import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
+import { ensureArrayElementSlot, ensureArrayField, scanValueEnd } from "./shared";
+
+@inline export function deserializeGenericArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+
+  if (srcStart >= srcEnd || load<u16>(srcStart) != BRACKET_LEFT) throw new Error("Failed to parse JSON!");
+  srcStart += 2;
+  if (srcStart >= srcEnd) throw new Error("Failed to parse JSON!");
+  if (load<u16>(srcStart) == BRACKET_RIGHT) return srcStart + 2;
+
+  let index = 0;
+
+  while (srcStart < srcEnd) {
+    const valueEnd = scanValueEnd(srcStart, srcEnd);
+    if (!valueEnd || valueEnd <= srcStart) break;
+
+    const slot = ensureArrayElementSlot<T>(out, index++);
+    store<valueof<T>>(slot, JSON.__deserialize<valueof<T>>(srcStart, valueEnd));
+    srcStart = valueEnd;
+
+    if (srcStart >= srcEnd) break;
+    const code = load<u16>(srcStart);
+    if (code == COMMA) {
+      srcStart += 2;
+      continue;
+    }
+    if (code == BRACKET_RIGHT) {
+      out.length = index;
+      return srcStart + 2;
+    }
+    break;
+  }
+
+  throw new Error("Failed to parse JSON!");
+}
+
+@inline export function deserializeGenericArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  return deserializeGenericArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+}

package/assembly/deserialize/swar/array/integer.ts

@@ -1,5 +1,5 @@
-import { deserializeIntegerField } from "../../integer";
-import { deserializeUnsignedField } from "../../unsigned";
+import { deserializeIntegerField } from "../../simple/integer";
+import { deserializeUnsignedField } from "../../simple/unsigned";
 import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { isSpace } from "../../../util";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
@@ -425,8 +425,7 @@ export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize
 }
 
 
-@inline export function deserializeIntegerArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  const out = ensureArrayField<T>(fieldPtr);
+@inline export function deserializeIntegerArrayInto<T extends number[]>(srcStart: usize, srcEnd: usize, out: T): usize {
   let index = 0;
 
   do {
@@ -459,3 +458,7 @@ export function deserializeIntegerArray_SWAR<T extends number[]>(srcStart: usize
 
   throw new Error("Failed to parse JSON!");
 }
+
+@inline export function deserializeIntegerArrayField<T extends number[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  return deserializeIntegerArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+}

package/assembly/deserialize/swar/array/object.ts

@@ -2,8 +2,7 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
 
-@inline export function deserializeObjectArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  const out = ensureArrayField<T>(fieldPtr);
+@inline export function deserializeObjectArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
   let index = 0;
 
   do {
@@ -19,11 +18,24 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
       const slot = ensureArrayElementSlot<T>(out, index);
       let value = load<valueof<T>>(slot);
       if (changetype<usize>(value) == 0) {
-        value = changetype<valueof<T>>(instantiate<nonnull<valueof<T>>>());
+        value = changetype<valueof<T>>(__new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()));
+        // @ts-ignore: supplied by transform
+        if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
+          // @ts-ignore: supplied by transform
+          changetype<nonnull<valueof<T>>>(value).__INITIALIZE();
+        }
         store<valueof<T>>(slot, value);
       }
 
-      srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE<valueof<T>>(srcStart, srcEnd, value);
+      const valueStart = srcStart;
+      // @ts-ignore: supplied by transform
+      if (isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)) {
+        // @ts-ignore: supplied by transform
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<valueof<T>>(valueStart, srcEnd, value);
+      } else {
+        // @ts-ignore: supplied by transform
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<valueof<T>>(valueStart, srcEnd, value);
+      }
       if (!srcStart || srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
@@ -42,3 +54,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
   throw new Error("Failed to parse JSON!");
 }
+
+@inline export function deserializeObjectArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  return deserializeObjectArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+}

package/assembly/deserialize/swar/array/shared.ts

@@ -6,8 +6,15 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
   if (!changetype<usize>(out)) {
     out = changetype<T>(instantiate<T>());
     store<T>(fieldPtr, out);
-  } else {
-    out.length = 0;
+  }
+  return out;
+}
+
+@inline export function ensureArrayFieldAt<T extends Array<any>>(dstObj: usize, dstOffset: usize): T {
+  let out = load<T>(dstObj, dstOffset);
+  if (!changetype<usize>(out)) {
+    out = changetype<T>(instantiate<T>());
+    store<T>(dstObj, out, dstOffset);
   }
   return out;
 }
@@ -22,7 +29,14 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 
 @inline export function ensureArrayElementSlot<T extends Array<any>>(out: T, index: i32): usize {
   const nextLength = index + 1;
-  if (out.length < nextLength) out.length = nextLength;
+  if (out.length < nextLength) {
+    out.length = nextLength;
+    const slot = out.dataStart + <usize>index * sizeof<valueof<T>>();
+    // Reference arrays can allocate recursively before the caller stores the new element.
+    // Zero the newly exposed slot immediately so incremental GC never observes a garbage pointer.
+    if (isManaged<valueof<T>>() || isReference<valueof<T>>()) store<usize>(slot, 0);
+    return slot;
+  }
   return out.dataStart + <usize>index * sizeof<valueof<T>>();
 }
 
@@ -88,7 +102,7 @@ import { BACK_SLASH, BRACE_LEFT, BRACE_RIGHT, BRACKET_LEFT, BRACKET_RIGHT, COMMA
 
   while (srcStart < srcEnd) {
     const code = load<u16>(srcStart);
-    if (code == COMMA || code == BRACKET_RIGHT) return srcStart;
+    if (code == COMMA || code == BRACKET_RIGHT || code == BRACE_RIGHT) return srcStart;
     srcStart += 2;
   }
 

package/assembly/deserialize/swar/array/string.ts

@@ -3,8 +3,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 import { deserializeStringField_SWAR } from "../string";
 
 
-@inline export function deserializeStringArrayField<T extends string[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  const out = ensureArrayField<T>(fieldPtr);
+@inline export function deserializeStringArrayInto<T extends string[]>(srcStart: usize, srcEnd: usize, out: T): usize {
   let index = 0;
 
   do {
@@ -37,3 +36,7 @@ import { deserializeStringField_SWAR } from "../string";
 
   throw new Error("Failed to parse JSON!");
 }
+
+@inline export function deserializeStringArrayField<T extends string[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  return deserializeStringArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+}

package/assembly/deserialize/swar/array/struct.ts

@@ -2,8 +2,7 @@ import { BRACKET_LEFT, BRACKET_RIGHT, COMMA } from "../../../custom/chars";
 import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
 
-@inline export function deserializeStructArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
-  const out = ensureArrayField<T>(fieldPtr);
+@inline export function deserializeStructArrayInto<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
   let index = 0;
 
   do {
@@ -19,11 +18,24 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
       const slot = ensureArrayElementSlot<T>(out, index);
       let value = load<valueof<T>>(slot);
       if (changetype<usize>(value) == 0) {
-        value = changetype<valueof<T>>(instantiate<nonnull<valueof<T>>>());
+        value = changetype<valueof<T>>(__new(offsetof<nonnull<valueof<T>>>(), idof<nonnull<valueof<T>>>()));
+        // @ts-ignore: supplied by transform
+        if (isDefined(changetype<nonnull<valueof<T>>>(value).__INITIALIZE)) {
+          // @ts-ignore: supplied by transform
+          changetype<nonnull<valueof<T>>>(value).__INITIALIZE();
+        }
         store<valueof<T>>(slot, value);
       }
 
-      srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE<valueof<T>>(srcStart, srcEnd, value);
+      const valueStart = srcStart;
+      // @ts-ignore: supplied by transform
+      if (isDefined(changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST)) {
+        // @ts-ignore: supplied by transform
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_FAST<valueof<T>>(valueStart, srcEnd, value);
+      } else {
+        // @ts-ignore: supplied by transform
+        srcStart = changetype<nonnull<valueof<T>>>(value).__DESERIALIZE_SLOW<valueof<T>>(valueStart, srcEnd, value);
+      }
       if (!srcStart || srcStart >= srcEnd) break;
 
       const code = load<u16>(srcStart);
@@ -42,3 +54,7 @@ import { ensureArrayElementSlot, ensureArrayField } from "./shared";
 
   throw new Error("Failed to parse JSON!");
 }
+
+@inline export function deserializeStructArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  return deserializeStructArrayInto<T>(srcStart, srcEnd, ensureArrayField<T>(fieldPtr));
+}

package/assembly/deserialize/swar/array.ts

@@ -4,15 +4,25 @@ import { deserializeArrayArrayField } from "./array/array";
 import { deserializeBooleanArrayField } from "./array/bool";
 import { deserializeBoxArrayField } from "./array/box";
 import { deserializeFloatArrayField } from "./array/float";
+import { deserializeGenericArrayField } from "./array/generic";
 import { deserializeIntegerArrayField } from "./array/integer";
 import { deserializeMapArrayField } from "./array/map";
 import { deserializeObjectArrayField } from "./array/object";
 import { deserializeRawArrayField } from "./array/raw";
 import { deserializeStringArrayField } from "./array/string";
 import { deserializeStructArrayField } from "./array/struct";
+import { deserializeArrayArrayInto } from "./array/array";
+import { deserializeBooleanArrayInto } from "./array/bool";
+import { deserializeFloatArrayInto } from "./array/float";
+import { deserializeGenericArrayInto } from "./array/generic";
+import { deserializeIntegerArrayInto } from "./array/integer";
+import { deserializeObjectArrayInto } from "./array/object";
+import { deserializeStringArrayInto } from "./array/string";
+import { deserializeStructArrayInto } from "./array/struct";
 
 
-@inline export function deserializeArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+@inline export function deserializeArrayField<T extends unknown[]>(srcStart: usize, srcEnd: usize, dstObj: usize, dstOffset: usize = 0): usize {
+  const fieldPtr = dstObj + dstOffset;
   if (isString<valueof<T>>()) {
     return deserializeStringArrayField<T>(srcStart, srcEnd, fieldPtr);
   } else if (isBoolean<valueof<T>>()) {
@@ -33,13 +43,17 @@ import { deserializeStructArrayField } from "./array/struct";
       return deserializeObjectArrayField<T>(srcStart, srcEnd, fieldPtr);
     } else if (type instanceof JSON.Raw) {
       return deserializeRawArrayField(srcStart, srcEnd, fieldPtr);
+    } else if (type instanceof Date) {
+      return deserializeGenericArrayField<T>(srcStart, srcEnd, fieldPtr);
+    } else if (type instanceof Set) {
+      return deserializeGenericArrayField<T>(srcStart, srcEnd, fieldPtr);
     } else if (type instanceof Map) {
       return deserializeMapArrayField<T>(srcStart, srcEnd, fieldPtr);
       // @ts-ignore: defined by transform
     } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
       return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
       // @ts-ignore: defined by transform
-    } else if (isDefined(type.__DESERIALIZE)) {
+    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
       return deserializeStructArrayField<T>(srcStart, srcEnd, fieldPtr);
     }
     throw new Error("Could not parse array field of type " + nameof<T>() + "!");
@@ -47,3 +61,43 @@ import { deserializeStructArrayField } from "./array/struct";
     throw new Error("Could not parse array field of type " + nameof<T>() + "!");
   }
 }
+
+@inline export function deserializeArrayInto_SWAR<T extends unknown[]>(srcStart: usize, srcEnd: usize, out: T): usize {
+  if (isString<valueof<T>>()) {
+    return deserializeStringArrayInto<T>(srcStart, srcEnd, out);
+  } else if (isBoolean<valueof<T>>()) {
+    return deserializeBooleanArrayInto<T>(srcStart, srcEnd, out);
+  } else if (isInteger<valueof<T>>()) {
+    return deserializeIntegerArrayInto<T>(srcStart, srcEnd, out);
+  } else if (isFloat<valueof<T>>()) {
+    return deserializeFloatArrayInto<T>(srcStart, srcEnd, out);
+  } else if (isArray<valueof<T>>()) {
+    return deserializeArrayArrayInto<T>(srcStart, srcEnd, out);
+  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+    const type = changetype<nonnull<valueof<T>>>(0);
+    if (type instanceof JSON.Value) {
+      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
+    } else if (type instanceof JSON.Box) {
+      throw new Error("Failed to parse JSON!");
+    } else if (type instanceof JSON.Obj) {
+      return deserializeObjectArrayInto<T>(srcStart, srcEnd, out);
+    } else if (type instanceof JSON.Raw) {
+      throw new Error("Failed to parse JSON!");
+    } else if (type instanceof Date) {
+      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
+    } else if (type instanceof Set) {
+      return deserializeGenericArrayInto<T>(srcStart, srcEnd, out);
+    } else if (type instanceof Map) {
+      throw new Error("Failed to parse JSON!");
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+      return deserializeStructArrayInto<T>(srcStart, srcEnd, out);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE_SLOW) || isDefined(type.__DESERIALIZE_FAST)) {
+      return deserializeStructArrayInto<T>(srcStart, srcEnd, out);
+    }
+    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
+  } else {
+    throw new Error("Could not parse array field of type " + nameof<T>() + "!");
+  }
+}