Arrays work

Author: surma

lib/asbind-instance/bind-function.js

@@ -49,27 +49,56 @@ function putArrayBuffer(asbindInstance, value, typeName) {
   );
 }
 
+function arrayInnerType(typeName) {
+  if (!typeName.startsWith("Array<")) {
+    throw Error(`${JSON.stringify(typeName)} is not an array type`);
+  }
+  return typeName.slice("Array<".length, -1);
+}
+
+function getArray(asbindInstance, value, typeName) {
+  const innerTypeName = arrayInnerType(typeName);
+  const innerTypeConverter = getConverterForType(innerTypeName);
+  const rawArray = asbindInstance.exports.__getArray(value);
+  return rawArray.map(v =>
+    innerTypeConverter.ascToJs(asbindInstance, v, innerTypeName)
+  );
+}
+
+function putArray(asbindInstance, value, typeName) {
+  const innerTypeName = arrayInnerType(typeName);
+  const innerTypeConverter = getConverterForType(innerTypeName);
+  const convertedValues = value.map(v =>
+    innerTypeConverter.jsToAsc(asbindInstance, v, innerTypeName)
+  );
+  return asbindInstance.exports.__newArray(
+    getTypeId(asbindInstance, typeName),
+    convertedValues
+  );
+}
+
 const converters = new Map([
-  [/void/, { ascToJs: nop, jsToAsc: nop }],
-  [/(i|u)(8|16|32)/, { ascToJs: nop, jsToAsc: nop }],
-  [/f(32|64)/, { ascToJs: nop, jsToAsc: nop }],
-  [/[sS]tring/, { ascToJs: getString, jsToAsc: putString }],
+  [/^void$/, { ascToJs: nop, jsToAsc: nop }],
+  [/^(i|u)(8|16|32)$/, { ascToJs: nop, jsToAsc: nop }],
+  [/^f(32|64)$/, { ascToJs: nop, jsToAsc: nop }],
+  [/^[sS]tring$/, { ascToJs: getString, jsToAsc: putString }],
   [
-    /(Ui|I)nt(8|16|32)Array/,
+    /^(Ui|I)nt(8|16|32)Array$/,
     { ascToJs: getArrayBufferView, jsToAsc: putArrayBuffer }
   ],
   [
-    /Big(Ui|I)nt64Array/,
+    /^Big(Ui|I)nt64Array$/,
     { ascToJs: getArrayBufferView, jsToAsc: putArrayBuffer }
   ],
   [
-    /Uint8ClampedArray/,
+    /^Uint8ClampedArray$/,
     { ascToJs: getArrayBufferView, jsToAsc: putArrayBuffer }
   ],
   [
-    /Float(32|64)Array/,
+    /^Float(32|64)Array$/,
     { ascToJs: getArrayBufferView, jsToAsc: putArrayBuffer }
-  ]
+  ],
+  [/^Array<.+>$/, { ascToJs: getArray, jsToAsc: putArray }]
 ]);
 
 const warned = new Set();

test/tests/array/asc.ts

@@ -0,0 +1,8 @@
+export function swapAndPad(a: Array<f64>, b: f64[]): Array<f64> {
+  const result = swappedConcat(a, b);
+  result.unshift(255);
+  result.push(255);
+  return result;
+}
+
+declare function swappedConcat(a: f64[], b: Array<f64>): f64[];

test/tests/array/test.js

@@ -0,0 +1,15 @@
+describe("as-bind", function() {
+  it("should handle array", async function() {
+    const instance = await AsBind.instantiate(this.rawModule, {
+      asc: {
+        swappedConcat(a, b) {
+          return [].concat(b, a);
+        }
+      }
+    });
+    assert(
+      instance.exports.swapAndPad([1, 2, 3], [10, 11, 12]).join(",") ===
+        [255, 10, 11, 12, 1, 2, 3, 255].join(",")
+    );
+  });
+});

transform.js

@@ -11,7 +11,11 @@ function elementHasFlag(el, flag) {
 }
 
 function typeName(type) {
-  return type.name.text ?? type.name.identifier.text;
+  let name = type.name.text ?? type.name.identifier.text;
+  if (type.typeArguments.length > 0) {
+    name = `${name}<${type.typeArguments.map(typeName).join(",")}>`;
+  }
+  return name;
 }
 
 function containingModule(func) {
@@ -24,8 +28,6 @@ function containingModule(func) {
 }
 
 function getFunctionTypeDescriptor(func) {
-  // TODO: Generics?
-  func = func.instances.get("");
   return {
     returnType: typeName(func.declaration.signature.returnType),
     parameters: func.declaration.signature.parameters.map(parameter =>
@@ -76,7 +78,6 @@ class AsBindTransform extends Transform {
 
     const typeIds = {};
     const importedFunctions = {};
-    debugger;
     for (const importedFunction of flatImportedFunctions) {
       // To know under what module name an imported function will be expected,
       // we have to find the containing module of the given function, take the