Use DataView in bindings generation (#2599)

Author: dcodeIO

src/bindings/js.ts

@@ -118,13 +118,20 @@ export declare function staticarrayI64(a: ArrayLike<bigint>): ArrayLike<bigint>;
  * @returns `~lib/array/Array<i32>`
  */
 export declare function arrayFunction(a: Array<number>, b: Array<number>): Array<number>;
+/**
+ * bindings/esm/arrayOfStringsFunction
+ * @param a `~lib/array/Array<~lib/string/String>`
+ * @param b `~lib/array/Array<~lib/string/String>`
+ * @returns `~lib/array/Array<~lib/string/String>`
+ */
+export declare function arrayOfStringsFunction(a: Array<string>, b: Array<string>): Array<string>;
 /**
  * bindings/esm/objectFunction
  * @param a `bindings/esm/PlainObject`
  * @param b `bindings/esm/PlainObject`
  * @returns `bindings/esm/PlainObject`
  */
-export declare function objectFunction(a: __Record12<undefined>, b: __Record12<undefined>): __Record12<never>;
+export declare function objectFunction(a: __Record13<undefined>, b: __Record13<undefined>): __Record13<never>;
 /**
  * bindings/esm/newInternref
  * @returns `bindings/esm/NonPlainObject`
@@ -149,7 +156,7 @@ export declare const fn: {
   get value(): __Internref4
 };
 /** bindings/esm/PlainObject */
-declare interface __Record12<TOmittable> {
+declare interface __Record13<TOmittable> {
   /** @type `i8` */
   a: number | TOmittable;
   /** @type `i16` */

tests/compiler/bindings/esm.debug.d.ts

@@ -137,40 +137,50 @@ async function instantiate(module, imports = {}) {
     },
     staticarrayFunction(a, b) {
       // bindings/esm/staticarrayFunction(~lib/staticarray/StaticArray<i32>, ~lib/staticarray/StaticArray<i32>) => ~lib/staticarray/StaticArray<i32>
-      a = __retain(__lowerStaticArray((pointer, value) => { new Int32Array(memory.buffer)[pointer >>> 2] = value; }, 8, 2, a, Int32Array) || __notnull());
-      b = __lowerStaticArray((pointer, value) => { new Int32Array(memory.buffer)[pointer >>> 2] = value; }, 8, 2, b, Int32Array) || __notnull();
+      a = __retain(__lowerStaticArray(__setU32, 8, 2, a, Int32Array) || __notnull());
+      b = __lowerStaticArray(__setU32, 8, 2, b, Int32Array) || __notnull();
       try {
-        return __liftStaticArray(pointer => new Int32Array(memory.buffer)[pointer >>> 2], 2, exports.staticarrayFunction(a, b) >>> 0);
+        return __liftStaticArray(__getI32, 2, exports.staticarrayFunction(a, b) >>> 0);
       } finally {
         __release(a);
       }
     },
     staticarrayU16(a) {
       // bindings/esm/staticarrayU16(~lib/staticarray/StaticArray<u16>) => ~lib/staticarray/StaticArray<u16>
-      a = __lowerStaticArray((pointer, value) => { new Uint16Array(memory.buffer)[pointer >>> 1] = value; }, 9, 1, a, Uint16Array) || __notnull();
-      return __liftStaticArray(pointer => new Uint16Array(memory.buffer)[pointer >>> 1], 1, exports.staticarrayU16(a) >>> 0);
+      a = __lowerStaticArray(__setU16, 9, 1, a, Uint16Array) || __notnull();
+      return __liftStaticArray(__getU16, 1, exports.staticarrayU16(a) >>> 0);
     },
     staticarrayI64(a) {
       // bindings/esm/staticarrayI64(~lib/staticarray/StaticArray<i64>) => ~lib/staticarray/StaticArray<i64>
-      a = __lowerStaticArray((pointer, value) => { new BigInt64Array(memory.buffer)[pointer >>> 3] = value || 0n; }, 10, 3, a, BigInt64Array) || __notnull();
-      return __liftStaticArray(pointer => new BigInt64Array(memory.buffer)[pointer >>> 3], 3, exports.staticarrayI64(a) >>> 0);
+      a = __lowerStaticArray(__setU64, 10, 3, a, BigInt64Array) || __notnull();
+      return __liftStaticArray(__getI64, 3, exports.staticarrayI64(a) >>> 0);
     },
     arrayFunction(a, b) {
       // bindings/esm/arrayFunction(~lib/array/Array<i32>, ~lib/array/Array<i32>) => ~lib/array/Array<i32>
-      a = __retain(__lowerArray((pointer, value) => { new Int32Array(memory.buffer)[pointer >>> 2] = value; }, 11, 2, a) || __notnull());
-      b = __lowerArray((pointer, value) => { new Int32Array(memory.buffer)[pointer >>> 2] = value; }, 11, 2, b) || __notnull();
+      a = __retain(__lowerArray(__setU32, 11, 2, a) || __notnull());
+      b = __lowerArray(__setU32, 11, 2, b) || __notnull();
       try {
-        return __liftArray(pointer => new Int32Array(memory.buffer)[pointer >>> 2], 2, exports.arrayFunction(a, b) >>> 0);
+        return __liftArray(__getI32, 2, exports.arrayFunction(a, b) >>> 0);
+      } finally {
+        __release(a);
+      }
+    },
+    arrayOfStringsFunction(a, b) {
+      // bindings/esm/arrayOfStringsFunction(~lib/array/Array<~lib/string/String>, ~lib/array/Array<~lib/string/String>) => ~lib/array/Array<~lib/string/String>
+      a = __retain(__lowerArray((pointer, value) => { __setU32(pointer, __lowerString(value) || __notnull()); }, 12, 2, a) || __notnull());
+      b = __lowerArray((pointer, value) => { __setU32(pointer, __lowerString(value) || __notnull()); }, 12, 2, b) || __notnull();
+      try {
+        return __liftArray(pointer => __liftString(__getU32(pointer)), 2, exports.arrayOfStringsFunction(a, b) >>> 0);
       } finally {
         __release(a);
       }
     },
     objectFunction(a, b) {
       // bindings/esm/objectFunction(bindings/esm/PlainObject, bindings/esm/PlainObject) => bindings/esm/PlainObject
-      a = __retain(__lowerRecord12(a) || __notnull());
-      b = __lowerRecord12(b) || __notnull();
+      a = __retain(__lowerRecord13(a) || __notnull());
+      b = __lowerRecord13(b) || __notnull();
       try {
-        return __liftRecord12(exports.objectFunction(a, b) >>> 0);
+        return __liftRecord13(exports.objectFunction(a, b) >>> 0);
       } finally {
         __release(a);
       }
@@ -202,51 +212,51 @@ async function instantiate(module, imports = {}) {
       }
     },
   }, exports);
-  function __lowerRecord12(value) {
+  function __lowerRecord13(value) {
     // bindings/esm/PlainObject
     // Hint: Opt-out from lowering as a record by providing an empty constructor
     if (value == null) return 0;
-    const pointer = exports.__pin(exports.__new(68, 12));
-    new Int8Array(memory.buffer)[pointer + 0 >>> 0] = value.a;
-    new Int16Array(memory.buffer)[pointer + 2 >>> 1] = value.b;
-    new Int32Array(memory.buffer)[pointer + 4 >>> 2] = value.c;
-    new BigInt64Array(memory.buffer)[pointer + 8 >>> 3] = value.d || 0n;
-    new Uint8Array(memory.buffer)[pointer + 16 >>> 0] = value.e;
-    new Uint16Array(memory.buffer)[pointer + 18 >>> 1] = value.f;
-    new Uint32Array(memory.buffer)[pointer + 20 >>> 2] = value.g;
-    new BigUint64Array(memory.buffer)[pointer + 24 >>> 3] = value.h || 0n;
-    new Int32Array(memory.buffer)[pointer + 32 >>> 2] = value.i;
-    new Uint32Array(memory.buffer)[pointer + 36 >>> 2] = value.j;
-    new Uint8Array(memory.buffer)[pointer + 40 >>> 0] = value.k ? 1 : 0;
-    new Float32Array(memory.buffer)[pointer + 44 >>> 2] = value.l;
-    new Float64Array(memory.buffer)[pointer + 48 >>> 3] = value.m;
-    __store_ref(pointer + 56, __lowerString(value.n));
-    __store_ref(pointer + 60, __lowerTypedArray(Uint8Array, 13, 0, value.o));
-    __store_ref(pointer + 64, __lowerArray((pointer, value) => { __store_ref(pointer, __lowerString(value) || __notnull()); }, 14, 2, value.p));
+    const pointer = exports.__pin(exports.__new(68, 13));
+    __setU8(pointer + 0, value.a);
+    __setU16(pointer + 2, value.b);
+    __setU32(pointer + 4, value.c);
+    __setU64(pointer + 8, value.d || 0n);
+    __setU8(pointer + 16, value.e);
+    __setU16(pointer + 18, value.f);
+    __setU32(pointer + 20, value.g);
+    __setU64(pointer + 24, value.h || 0n);
+    __setU32(pointer + 32, value.i);
+    __setU32(pointer + 36, value.j);
+    __setU8(pointer + 40, value.k ? 1 : 0);
+    __setF32(pointer + 44, value.l);
+    __setF64(pointer + 48, value.m);
+    __setU32(pointer + 56, __lowerString(value.n));
+    __setU32(pointer + 60, __lowerTypedArray(Uint8Array, 14, 0, value.o));
+    __setU32(pointer + 64, __lowerArray((pointer, value) => { __setU32(pointer, __lowerString(value) || __notnull()); }, 12, 2, value.p));
     exports.__unpin(pointer);
     return pointer;
   }
-  function __liftRecord12(pointer) {
+  function __liftRecord13(pointer) {
     // bindings/esm/PlainObject
     // Hint: Opt-out from lifting as a record by providing an empty constructor
     if (!pointer) return null;
     return {
-      a: new Int8Array(memory.buffer)[pointer + 0 >>> 0],
-      b: new Int16Array(memory.buffer)[pointer + 2 >>> 1],
-      c: new Int32Array(memory.buffer)[pointer + 4 >>> 2],
-      d: new BigInt64Array(memory.buffer)[pointer + 8 >>> 3],
-      e: new Uint8Array(memory.buffer)[pointer + 16 >>> 0],
-      f: new Uint16Array(memory.buffer)[pointer + 18 >>> 1],
-      g: new Uint32Array(memory.buffer)[pointer + 20 >>> 2],
-      h: new BigUint64Array(memory.buffer)[pointer + 24 >>> 3],
-      i: new Int32Array(memory.buffer)[pointer + 32 >>> 2],
-      j: new Uint32Array(memory.buffer)[pointer + 36 >>> 2],
-      k: new Uint8Array(memory.buffer)[pointer + 40 >>> 0] != 0,
-      l: new Float32Array(memory.buffer)[pointer + 44 >>> 2],
-      m: new Float64Array(memory.buffer)[pointer + 48 >>> 3],
-      n: __liftString(new Uint32Array(memory.buffer)[pointer + 56 >>> 2]),
-      o: __liftTypedArray(Uint8Array, new Uint32Array(memory.buffer)[pointer + 60 >>> 2]),
-      p: __liftArray(pointer => __liftString(new Uint32Array(memory.buffer)[pointer >>> 2]), 2, new Uint32Array(memory.buffer)[pointer + 64 >>> 2]),
+      a: __getI8(pointer + 0),
+      b: __getI16(pointer + 2),
+      c: __getI32(pointer + 4),
+      d: __getI64(pointer + 8),
+      e: __getU8(pointer + 16),
+      f: __getU16(pointer + 18),
+      g: __getU32(pointer + 20),
+      h: __getU64(pointer + 24),
+      i: __getI32(pointer + 32),
+      j: __getU32(pointer + 36),
+      k: __getU8(pointer + 40) != 0,
+      l: __getF32(pointer + 44),
+      m: __getF64(pointer + 48),
+      n: __liftString(__getU32(pointer + 56)),
+      o: __liftTypedArray(Uint8Array, __getU32(pointer + 60)),
+      p: __liftArray(pointer => __liftString(__getU32(pointer)), 2, __getU32(pointer + 64)),
     };
   }
   function __liftBuffer(pointer) {
@@ -282,9 +292,8 @@ async function instantiate(module, imports = {}) {
   function __liftArray(liftElement, align, pointer) {
     if (!pointer) return null;
     const
-      memoryU32 = new Uint32Array(memory.buffer),
-      dataStart = memoryU32[pointer + 4 >>> 2],
-      length = memoryU32[pointer + 12 >>> 2],
+      dataStart = __getU32(pointer + 4),
+      length = __dataview.getUint32(pointer + 12, true),
       values = new Array(length);
     for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
     return values;
@@ -294,44 +303,41 @@ async function instantiate(module, imports = {}) {
     const
       length = values.length,
       buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
-      header = exports.__pin(exports.__new(16, id)) >>> 0,
-      memoryU32 = new Uint32Array(memory.buffer);
-    memoryU32[header + 0 >>> 2] = buffer;
-    memoryU32[header + 4 >>> 2] = buffer;
-    memoryU32[header + 8 >>> 2] = length << align;
-    memoryU32[header + 12 >>> 2] = length;
+      header = exports.__pin(exports.__new(16, id)) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
+    __dataview.setUint32(header + 12, length, true);
     for (let i = 0; i < length; ++i) lowerElement(buffer + (i << align >>> 0), values[i]);
     exports.__unpin(buffer);
     exports.__unpin(header);
     return header;
   }
   function __liftTypedArray(constructor, pointer) {
     if (!pointer) return null;
-    const memoryU32 = new Uint32Array(memory.buffer);
     return new constructor(
       memory.buffer,
-      memoryU32[pointer + 4 >>> 2],
-      memoryU32[pointer + 8 >>> 2] / constructor.BYTES_PER_ELEMENT
+      __getU32(pointer + 4),
+      __dataview.getUint32(pointer + 8, true) / constructor.BYTES_PER_ELEMENT
     ).slice();
   }
   function __lowerTypedArray(constructor, id, align, values) {
     if (values == null) return 0;
     const
       length = values.length,
       buffer = exports.__pin(exports.__new(length << align, 1)) >>> 0,
-      header = exports.__new(12, id) >>> 0,
-      memoryU32 = new Uint32Array(memory.buffer);
-    memoryU32[header + 0 >>> 2] = buffer;
-    memoryU32[header + 4 >>> 2] = buffer;
-    memoryU32[header + 8 >>> 2] = length << align;
+      header = exports.__new(12, id) >>> 0;
+    __setU32(header + 0, buffer);
+    __dataview.setUint32(header + 4, buffer, true);
+    __dataview.setUint32(header + 8, length << align, true);
     new constructor(memory.buffer, buffer, length).set(values);
     exports.__unpin(buffer);
     return header;
   }
   function __liftStaticArray(liftElement, align, pointer) {
     if (!pointer) return null;
     const
-      length = new Uint32Array(memory.buffer)[pointer - 4 >>> 2] >>> align,
+      length = __getU32(pointer - 4) >>> align,
       values = new Array(length);
     for (let i = 0; i < length; ++i) values[i] = liftElement(pointer + (i << align >>> 0));
     return values;
@@ -382,8 +388,134 @@ async function instantiate(module, imports = {}) {
   function __notnull() {
     throw TypeError("value must not be null");
   }
-  function __store_ref(pointer, value) {
-    new Uint32Array(memory.buffer)[pointer >>> 2] = value;
+  let __dataview = new DataView(memory.buffer);
+  function __setU8(pointer, value) {
+    try {
+      __dataview.setUint8(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint8(pointer, value, true);
+    }
+  }
+  function __setU16(pointer, value) {
+    try {
+      __dataview.setUint16(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint16(pointer, value, true);
+    }
+  }
+  function __setU32(pointer, value) {
+    try {
+      __dataview.setUint32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setUint32(pointer, value, true);
+    }
+  }
+  function __setU64(pointer, value) {
+    try {
+      __dataview.setBigUint64(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setBigUint64(pointer, value, true);
+    }
+  }
+  function __setF32(pointer, value) {
+    try {
+      __dataview.setFloat32(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setFloat32(pointer, value, true);
+    }
+  }
+  function __setF64(pointer, value) {
+    try {
+      __dataview.setFloat64(pointer, value, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      __dataview.setFloat64(pointer, value, true);
+    }
+  }
+  function __getI8(pointer) {
+    try {
+      return __dataview.getInt8(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getInt8(pointer, true);
+    }
+  }
+  function __getU8(pointer) {
+    try {
+      return __dataview.getUint8(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint8(pointer, true);
+    }
+  }
+  function __getI16(pointer) {
+    try {
+      return __dataview.getInt16(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getInt16(pointer, true);
+    }
+  }
+  function __getU16(pointer) {
+    try {
+      return __dataview.getUint16(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint16(pointer, true);
+    }
+  }
+  function __getI32(pointer) {
+    try {
+      return __dataview.getInt32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getInt32(pointer, true);
+    }
+  }
+  function __getU32(pointer) {
+    try {
+      return __dataview.getUint32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getUint32(pointer, true);
+    }
+  }
+  function __getI64(pointer) {
+    try {
+      return __dataview.getBigInt64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigInt64(pointer, true);
+    }
+  }
+  function __getU64(pointer) {
+    try {
+      return __dataview.getBigUint64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getBigUint64(pointer, true);
+    }
+  }
+  function __getF32(pointer) {
+    try {
+      return __dataview.getFloat32(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getFloat32(pointer, true);
+    }
+  }
+  function __getF64(pointer) {
+    try {
+      return __dataview.getFloat64(pointer, true);
+    } catch {
+      __dataview = new DataView(memory.buffer);
+      return __dataview.getFloat64(pointer, true);
+    }
   }
   exports._start();
   return adaptedExports;
@@ -408,6 +540,7 @@ export const {
   staticarrayU16,
   staticarrayI64,
   arrayFunction,
+  arrayOfStringsFunction,
   objectFunction,
   newInternref,
   internrefFunction,