json-as 1.2.6 → 1.3.0

package/assembly/custom/util.ts

@@ -15,11 +15,7 @@
  * @param str - Any number. Can include scientific notation.
  */
 // @ts-ignore: Decorator
-@inline export function snip_fast<T extends number>(
-  str: string,
-  len: u32 = 0,
-  offset: u32 = 0,
-): T {
+@inline export function snip_fast<T extends number>(str: string, len: u32 = 0, offset: u32 = 0): T {
   if (isSigned<T>()) {
     const firstChar: u32 = load<u16>(changetype<usize>(str));
     if (firstChar == 48) return 0 as T;
@@ -39,31 +35,19 @@
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return -(
-                val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)
-              ) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(
-                val *
-                10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)
-              ) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return -(
-                val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)
-              ) as T;
+              return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return -(
-                val *
-                10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)
-              ) as T;
+              return -(val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
             val = (val * 100 + (low - 48) * 10 + (high - 48)) as T;
@@ -78,16 +62,10 @@
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return -(
-              val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)
-            ) as T;
+            return -(val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return -(
-              val *
-              10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)
-            ) as T;
+            return -(val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else {
           val = (val * 10 + (ch - 48)) as T;
@@ -106,21 +84,17 @@
             // The first char (f) is E or e
             // We push the offset up by two and apply the notation.
             if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-              return (val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val *
-                10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
             }
           } else if (high > 57) {
             if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-              return (val /
-                10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+              return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
             } else {
               // Inlined this operation instead of using a loop
-              return (val *
-                10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
+              return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
             }
           } else {
             // Optimized with multiplications and shifts.
@@ -135,12 +109,10 @@
         // e is 101 and E is 69.
         if (ch > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            val = (val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+            val = (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            val = (val *
-              10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+            val = (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
           return val as T;
         } else {
@@ -165,21 +137,17 @@
           // The first char (f) is E or e
           // We push the offset up by two and apply the notation.
           if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-            return (val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val *
-              10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
           }
         } else if (high > 57) {
           if (load<u16>(changetype<usize>(str) + <usize>offset + 4) == 45) {
-            return (val /
-              10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+            return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
           } else {
             // Inlined this operation instead of using a loop
-            return (val *
-              10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
+            return (val * 10 ** (__atoi_fast<u32>(str, offset + 4, offset + 6) + 1)) as T;
           }
         } else {
           // Optimized with multiplications and shifts.
@@ -194,12 +162,10 @@
       // e is 101 and E is 69.
       if (ch > 57) {
         if (load<u16>(changetype<usize>(str) + <usize>offset + 2) == 45) {
-          return (val /
-            10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
+          return (val / 10 ** (__atoi_fast<u32>(str, offset + 6, offset + 8) - 1)) as T;
         } else {
           // Inlined this operation instead of using a loop
-          return (val *
-            10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
+          return (val * 10 ** (__atoi_fast<u32>(str, offset + 2, offset + 4) + 1)) as T;
         }
       } else {
         val = (val * 10 + (ch - 48)) as T;
@@ -214,11 +180,7 @@
  */
 
 // @ts-ignore
-@inline export function __atoi_fast<T extends number>(
-  str: string,
-  start: u32 = 0,
-  end: u32 = 0,
-): T {
+@inline export function __atoi_fast<T extends number>(str: string, start: u32 = 0, end: u32 = 0): T {
   // @ts-ignore
   let val: T = 0;
   if (!end) end = start + u32(str.length << 1);
@@ -227,21 +189,18 @@
     if (load<u16>(changetype<usize>(str) + <usize>start) == 45) {
       start += 2;
       for (; start < end; start += 2) {
-        val = (val * 10 +
-          (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return -val as T;
     } else {
       for (; start < end; start += 2) {
-        val = (val * 10 +
-          (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+        val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
       }
       return val as T;
     }
   } else {
     for (; start < end; start += 2) {
-      val = (val * 10 +
-        (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
+      val = (val * 10 + (load<u16>(changetype<usize>(str) + <usize>start) - 48)) as T;
     }
     return val as T;
   }
@@ -308,12 +267,7 @@
 }
 
 // @ts-ignore
-@inline export function containsCodePoint(
-  str: string,
-  code: u32,
-  start: i32,
-  end: i32,
-): bool {
+@inline export function containsCodePoint(str: string, code: u32, start: i32, end: i32): bool {
   for (let i = start; i <= end; i++) {
     if (unsafeCharCodeAt(str, i) == code) return true;
   }

package/assembly/deserialize/float.ts

@@ -0,0 +1,181 @@
+import { ptrToStr } from "../util/ptrToStr";
+
+// @ts-ignore: inline
+@inline function pow10Fast(exponent: u32): f64 {
+  let result = 1.0;
+  if (exponent & 1) result *= 1e1;
+  if (exponent & 2) result *= 1e2;
+  if (exponent & 4) result *= 1e4;
+  if (exponent & 8) result *= 1e8;
+  if (exponent & 16) result *= 1e16;
+  if (exponent & 32) result *= 1e32;
+  if (exponent & 64) result *= 1e64;
+  if (exponent & 128) result *= 1e128;
+  if (exponent & 256) result *= 1e256;
+  return result;
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloat<T>(srcStart: usize, srcEnd: usize): T {
+  let negative = false;
+  if (load<u16>(srcStart) == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) unreachable();
+  }
+
+  let value: f64 = 0.0;
+  let seenDigit = false;
+
+  while (srcStart < srcEnd) {
+    const digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10.0 + <f64>digit;
+    seenDigit = true;
+    srcStart += 2;
+  }
+
+  if (srcStart < srcEnd && load<u16>(srcStart) == 46) {
+    srcStart += 2;
+    let fraction: u64 = 0;
+    let digits: u32 = 0;
+    while (srcStart < srcEnd) {
+      const digit = <u32>load<u16>(srcStart) - 48;
+      if (digit > 9) break;
+      fraction = fraction * 10 + digit;
+      digits += 1;
+      seenDigit = true;
+      srcStart += 2;
+    }
+    if (digits != 0) value += <f64>fraction / pow10Fast(digits);
+  }
+
+  if (!seenDigit) {
+    // @ts-ignore
+    const type: T = 0;
+    // @ts-ignore
+    if (type instanceof f64) return f64.parse(ptrToStr(srcStart, srcEnd));
+    // @ts-ignore
+    return f32.parse(ptrToStr(srcStart, srcEnd));
+  }
+
+  if (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == 101 || code == 69) {
+      srcStart += 2;
+      if (srcStart >= srcEnd) unreachable();
+
+      let exponentNegative = false;
+      let exponentCode = load<u16>(srcStart);
+      if (exponentCode == 45 || exponentCode == 43) {
+        exponentNegative = exponentCode == 45;
+        srcStart += 2;
+        if (srcStart >= srcEnd) unreachable();
+        exponentCode = load<u16>(srcStart);
+      }
+
+      let exponent = <u32>exponentCode - 48;
+      if (exponent > 9) unreachable();
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const digit = <u32>load<u16>(srcStart) - 48;
+        if (digit > 9) break;
+        exponent = exponent * 10 + digit;
+        srcStart += 2;
+      }
+
+      const power = pow10Fast(exponent);
+      value = exponentNegative ? value / power : value * power;
+    }
+  }
+
+  if (negative) value = -value;
+
+  // @ts-ignore
+  const type: T = 0;
+  // @ts-ignore
+  if (type instanceof f64) return <T>value;
+  // @ts-ignore
+  return <T>(<f32>value);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeFloatField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  let negative = false;
+  if (load<u16>(srcStart) == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) unreachable();
+  }
+
+  let value: f64 = 0.0;
+  let seenDigit = false;
+
+  while (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    const digit = <u32>code - 48;
+    if (digit > 9) break;
+    value = value * 10.0 + <f64>digit;
+    seenDigit = true;
+    srcStart += 2;
+  }
+
+  if (srcStart < srcEnd && load<u16>(srcStart) == 46) {
+    srcStart += 2;
+    let fraction: u64 = 0;
+    let digits: u32 = 0;
+    while (srcStart < srcEnd) {
+      const code = load<u16>(srcStart);
+      const digit = <u32>code - 48;
+      if (digit > 9) break;
+      fraction = fraction * 10 + digit;
+      digits += 1;
+      seenDigit = true;
+      srcStart += 2;
+    }
+    if (digits != 0) value += <f64>fraction / pow10Fast(digits);
+  }
+
+  if (!seenDigit) unreachable();
+
+  if (srcStart < srcEnd) {
+    const code = load<u16>(srcStart);
+    if (code == 101 || code == 69) {
+      srcStart += 2;
+      if (srcStart >= srcEnd) unreachable();
+
+      let exponentNegative = false;
+      let exponentCode = load<u16>(srcStart);
+      if (exponentCode == 45 || exponentCode == 43) {
+        exponentNegative = exponentCode == 45;
+        srcStart += 2;
+        if (srcStart >= srcEnd) unreachable();
+        exponentCode = load<u16>(srcStart);
+      }
+
+      let exponent = <u32>exponentCode - 48;
+      if (exponent > 9) unreachable();
+      srcStart += 2;
+      while (srcStart < srcEnd) {
+        const code = load<u16>(srcStart);
+        const digit = <u32>code - 48;
+        if (digit > 9) break;
+        exponent = exponent * 10 + digit;
+        srcStart += 2;
+      }
+
+      const power = pow10Fast(exponent);
+      value = exponentNegative ? value / power : value * power;
+    }
+  }
+
+  if (negative) value = -value;
+
+  if (sizeof<T>() == sizeof<f32>()) {
+    store<f32>(fieldPtr, <f32>value);
+  } else {
+    store<f64>(fieldPtr, value);
+  }
+
+  return srcStart;
+}

package/assembly/deserialize/helpers/uint.ts

@@ -0,0 +1,12 @@
+export function deserializeUintScan<T extends number>(src: usize, dst: usize): usize {
+  let digit = <T>load<u16>(src) - 48;
+  if (digit > 9) abort("Found invalid digit");
+  let val = digit;
+  src += 2;
+  while ((digit = <u32>load<u16>(src) - 48) < 10) {
+    val = val * 10 + digit;
+    src += 2;
+  }
+  store<T>(dst, val);
+  return src;
+}

package/assembly/deserialize/index/arbitrary.ts

@@ -0,0 +1,25 @@
+import { JSON } from "../..";
+import { deserializeArray } from "./array";
+import { deserializeBoolean } from "./bool";
+import { deserializeFloat } from "./float";
+import { deserializeObject } from "./object";
+import { deserializeString } from "./string";
+import { BRACE_LEFT, BRACKET_LEFT, CHAR_N, QUOTE } from "../../custom/chars";
+
+export function deserializeArbitrary(srcStart: usize, srcEnd: usize, dst: usize): JSON.Value {
+  const firstChar = load<u16>(srcStart);
+  if (firstChar == QUOTE) {
+    return JSON.Value.from(deserializeString(srcStart, srcEnd));
+  } else if (firstChar == BRACE_LEFT) {
+    return JSON.Value.from(deserializeObject(srcStart, srcEnd, 0));
+  } else if (firstChar - 48 <= 9 || firstChar == 45) {
+    return JSON.Value.from(deserializeFloat<f64>(srcStart, srcEnd));
+  } else if (firstChar == BRACKET_LEFT) {
+    return JSON.Value.from(deserializeArray<JSON.Value[]>(srcStart, srcEnd, 0));
+  } else if (firstChar == 116 || firstChar == 102) {
+    return JSON.Value.from(deserializeBoolean(srcStart, srcEnd));
+  } else if (firstChar == CHAR_N) {
+    return JSON.Value.from<usize>(0);
+  }
+  return unreachable();
+}

package/assembly/deserialize/index/array.ts

@@ -0,0 +1,61 @@
+import { JSON, JSONMode } from "../..";
+import { deserializeArbitraryArray } from "../simple/array/arbitrary";
+import { deserializeArrayArray } from "../simple/array/array";
+import { deserializeBooleanArray } from "../simple/array/bool";
+import { deserializeBoxArray } from "../simple/array/box";
+import { deserializeFloatArray } from "../simple/array/float";
+import { deserializeIntegerArray as deserializeIntegerArray_NAIVE } from "../simple/array/integer";
+import { deserializeMapArray } from "../simple/array/map";
+import { deserializeObjectArray } from "../simple/array/object";
+import { deserializeRawArray } from "../simple/array/raw";
+import { deserializeStringArray } from "../simple/array/string";
+import { deserializeStructArray } from "../simple/array/struct";
+import { deserializeIntegerArray_SIMD } from "../simd/array/integer";
+import { deserializeIntegerArray_SWAR } from "../swar/array/integer";
+
+export { deserializeArrayField, deserializeArrayField as deserializeArrayField_SWAR } from "../swar/array";
+
+export function deserializeArray<T extends unknown[]>(srcStart: usize, srcEnd: usize, dst: usize): T {
+  if (isString<valueof<T>>()) {
+    return <T>deserializeStringArray(srcStart, srcEnd, dst);
+  } else if (isBoolean<valueof<T>>()) {
+    return deserializeBooleanArray<T>(srcStart, srcEnd, dst);
+  } else if (isInteger<valueof<T>>()) {
+    if (JSON_MODE == JSONMode.SIMD) {
+      // @ts-ignore: integer array branch
+      return deserializeIntegerArray_SIMD<T>(srcStart, srcEnd, dst);
+    } else if (JSON_MODE == JSONMode.SWAR) {
+      // @ts-ignore: integer array branch
+      return deserializeIntegerArray_SWAR<T>(srcStart, srcEnd, dst);
+    } else {
+      // @ts-ignore: integer array branch
+      return deserializeIntegerArray_NAIVE<T>(srcStart, srcEnd, dst);
+    }
+  } else if (isFloat<valueof<T>>()) {
+    return deserializeFloatArray<T>(srcStart, srcEnd, dst);
+  } else if (isArray<valueof<T>>()) {
+    return deserializeArrayArray<T>(srcStart, srcEnd, dst);
+  } else if (isManaged<valueof<T>>() || isReference<valueof<T>>()) {
+    const type = changetype<nonnull<valueof<T>>>(0);
+    if (type instanceof JSON.Value) {
+      return deserializeArbitraryArray(srcStart, srcEnd, dst) as T;
+    } else if (type instanceof JSON.Box) {
+      return deserializeBoxArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof JSON.Obj) {
+      return deserializeObjectArray<T>(srcStart, srcEnd, dst);
+    } else if (type instanceof JSON.Raw) {
+      return deserializeRawArray(srcStart, srcEnd, dst) as T;
+    } else if (type instanceof Map) {
+      return deserializeMapArray<T>(srcStart, srcEnd, dst);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE_CUSTOM)) {
+      return deserializeStructArray<T>(srcStart, srcEnd, dst);
+      // @ts-ignore: defined by transform
+    } else if (isDefined(type.__DESERIALIZE)) {
+      return deserializeStructArray<T>(srcStart, srcEnd, dst);
+    }
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+  } else {
+    throw new Error("Could not parse array of type " + nameof<T>() + "!");
+  }
+}

package/assembly/deserialize/index/bool.ts

@@ -0,0 +1 @@
+export { deserializeBoolean } from "../simple/bool";

package/assembly/deserialize/index/date.ts

@@ -0,0 +1 @@
+export { deserializeDate } from "../simple/date";

package/assembly/deserialize/index/float.ts

@@ -0,0 +1 @@
+export { deserializeFloat } from "../float";

package/assembly/deserialize/index/integer.ts

@@ -0,0 +1 @@
+export { deserializeInteger } from "../integer";

package/assembly/deserialize/index/map.ts

@@ -0,0 +1 @@
+export { deserializeMap } from "../simple/map";

package/assembly/deserialize/index/object.ts

@@ -0,0 +1 @@
+export { deserializeObject } from "../simple/object";

package/assembly/deserialize/index/raw.ts

@@ -0,0 +1 @@
+export { deserializeRaw } from "../simple/raw";

package/assembly/deserialize/index/set.ts

@@ -0,0 +1 @@
+export { deserializeSet } from "../simple/set";

package/assembly/deserialize/index/staticarray.ts

@@ -0,0 +1 @@
+export { deserializeStaticArray } from "../simple/staticarray";

package/assembly/deserialize/index/string.ts

@@ -0,0 +1,15 @@
+import { JSONMode } from "../..";
+import { deserializeString as deserializeString_NAIVE } from "../simple/string";
+import { deserializeString_SIMD } from "../simd/string";
+import { deserializeString_SWAR } from "../swar/string";
+
+
+@inline export function deserializeString(srcStart: usize, srcEnd: usize): string {
+  if (JSON_MODE == JSONMode.SIMD) {
+    return deserializeString_SIMD(srcStart, srcEnd);
+  } else if (JSON_MODE == JSONMode.NAIVE) {
+    return deserializeString_NAIVE(srcStart, srcEnd);
+  } else {
+    return deserializeString_SWAR(srcStart, srcEnd);
+  }
+}

package/assembly/deserialize/index/struct.ts

@@ -0,0 +1 @@
+export { deserializeStruct } from "../simple/struct";

package/assembly/deserialize/index/typedarray.ts

@@ -0,0 +1 @@
+export { deserializeArrayBuffer, deserializeTypedArray } from "../simple/typedarray";

package/assembly/deserialize/index/unsigned.ts

@@ -0,0 +1 @@
+export { deserializeUnsigned } from "../unsigned";

package/assembly/deserialize/index.ts

@@ -0,0 +1,14 @@
+export * from "./index/arbitrary";
+export * from "./index/array";
+export * from "./index/bool";
+export * from "./index/date";
+export * from "./index/float";
+export * from "./index/integer";
+export * from "./index/map";
+export * from "./index/object";
+export * from "./index/raw";
+export * from "./index/set";
+export * from "./index/staticarray";
+export * from "./index/string";
+export * from "./index/struct";
+export * from "./index/unsigned";

package/assembly/deserialize/integer.ts

@@ -0,0 +1,42 @@
+import { atoi } from "../util/atoi";
+
+// @ts-ignore: inline
+@inline export function deserializeInteger<T>(srcStart: usize, srcEnd: usize): T {
+  return atoi<T>(srcStart, srcEnd);
+}
+
+// @ts-ignore: inline
+@inline export function deserializeIntegerField<T extends number>(srcStart: usize, srcEnd: usize, fieldPtr: usize): usize {
+  let negative = false;
+  if (load<u16>(srcStart) == 45) {
+    negative = true;
+    srcStart += 2;
+    if (srcStart >= srcEnd) unreachable();
+  }
+
+  let digit = <u32>load<u16>(srcStart) - 48;
+  if (digit > 9) unreachable();
+
+  let value: u64 = digit;
+  srcStart += 2;
+  while (srcStart < srcEnd) {
+    digit = <u32>load<u16>(srcStart) - 48;
+    if (digit > 9) break;
+    value = value * 10 + digit;
+    srcStart += 2;
+  }
+
+  if (sizeof<T>() == sizeof<i8>()) {
+    store<i8>(fieldPtr, negative ? -(<i8>value) : <i8>value);
+  } else if (sizeof<T>() == sizeof<i16>()) {
+    store<i16>(fieldPtr, negative ? -(<i16>value) : <i16>value);
+  } else if (sizeof<T>() == sizeof<i32>()) {
+    store<i32>(fieldPtr, negative ? -(<i32>value) : <i32>value);
+  } else if (sizeof<T>() == sizeof<isize>()) {
+    store<isize>(fieldPtr, negative ? -(<isize>value) : <isize>value);
+  } else {
+    store<i64>(fieldPtr, negative ? -(<i64>value) : <i64>value);
+  }
+
+  return srcStart;
+}