Handle prototype chain of imports object

Author: surma

lib/asbind-instance/asbind-instance.js

@@ -6,18 +6,17 @@ import { isReservedExportKey } from "./reserved-export-keys";
 
 const SECTION_NAME = "as-bind_bindings";
 
-// Need to traverse the importObject and bind all import functions
-function traverseObjectAndRunCallback(obj, callback, keys = [], baseObj = obj) {
-  if (!obj) {
-    return;
-  }
-  for (const key of Object.keys(obj)) {
-    if (obj[key] && Object.getPrototypeOf(obj[key]) === Object.prototype) {
-      traverseObjectAndRunCallback(obj[key], callback, [...keys, key], baseObj);
-      continue;
-    }
-    callback(obj[key], [...keys, key], baseObj, key, obj);
+// Basically a deep-copy, but can be limited in levels.
+function copyObject(obj, { depth = Number.POSITIVE_INFINITY } = {}) {
+  if (depth <= 0 || !obj || typeof obj !== "object") {
+    return obj;
   }
+  return Object.fromEntries(
+    Object.entries(obj).map(([key, val]) => [
+      key,
+      copyObject(val, { depth: depth - 1 })
+    ])
+  );
 }
 
 async function compileStreaming(source) {
@@ -80,19 +79,17 @@ export default class AsbindInstance {
   }
 
   async _instantiate(source, importObject) {
-    this.importObject = importObject;
     this.module = await compileStreaming(source);
 
     this._validate();
     this.typeDescriptor = extractTypeDescriptor(this.module);
-    this._instantiateBindImportFunctions();
+    this._instantiateBindImportFunctions(importObject);
     // Instantiate the module through the loader
     this.loadedModule = await asbindInstantiate(this.module, this.importObject);
     this._instantiateBindUnboundExports();
   }
 
   _instantiateSync(source, importObject) {
-    this.importObject = importObject;
     this.module = new WebAssembly.Module(source);
 
     this._validate();
@@ -103,46 +100,41 @@ export default class AsbindInstance {
   }
 
   _instantiateBindImportFunctions(importObject) {
-    // Need to traverse the importObject and bind all import functions
-    traverseObjectAndRunCallback(
-      this.importObject,
-      (importedFunction, keys, importObject, currentKey, currentObj) => {
-        if (typeof importedFunction === "function") {
-          // Save original function
-          // TODO: Maybe use symbols here instead
-          currentObj[`__asbind_unbound_${currentKey}`] = importedFunction;
-          currentObj[currentKey] = bindImportFunction(
-            this,
-            importedFunction,
-            keys
-          );
-        }
+    this.importObject = copyObject(importObject, { depth: 2 });
+
+    for (const [moduleName, moduleDescriptor] of Object.entries(
+      this.typeDescriptor.importedFunctions
+    )) {
+      for (const [importedFunctionName, descriptor] of Object.entries(
+        moduleDescriptor
+      )) {
+        this.importObject[moduleName][
+          `__asbind_unbound_${importedFunctionName}`
+        ] = importObject[moduleName][importedFunctionName];
+        this.importObject[moduleName][
+          importedFunctionName
+        ] = bindImportFunction(
+          this,
+          importObject[moduleName][importedFunctionName],
+          descriptor
+        );
       }
-    );
+    }
   }
 
   _instantiateBindUnboundExports() {
     // Wrap appropriate the appropriate export functions
     const unboundExports = this.loadedModule.exports;
-    this.exports = {};
-
-    traverseObjectAndRunCallback(
-      unboundExports,
-      (exportedValue, keys, importObject, currentKey, currentObj) => {
-        if (
-          typeof exportedValue === "function" &&
-          !isReservedExportKey(currentKey)
-        ) {
-          // Wrap the export
-          this.exports[currentKey] = bindExportFunction(
-            this,
-            exportedValue,
-            currentKey
-          );
-        } else {
-          this.exports[currentKey] = exportedValue;
-        }
-      }
-    );
+    this.exports = copyObject(unboundExports, { depth: 1 });
+
+    for (const [exportedFunctionName, descriptor] of Object.entries(
+      this.typeDescriptor.exportedFunctions
+    )) {
+      this.exports[exportedFunctionName] = bindExportFunction(
+        this,
+        unboundExports[exportedFunctionName],
+        descriptor
+      );
+    }
   }
 }

lib/asbind-instance/bind-function.js

@@ -11,27 +11,11 @@ function getFunctionFromKeyPath(baseObject, keys) {
   return result;
 }
 
-// Function that takes in an asbindInstance, an imported function and the path to the imported function
-// on the import object.
-// (E.g ["env", "myObject", "myFunction"] for {env: myObject: {myFunction: () => {}}})
 export function bindImportFunction(
   asbindInstance,
   importedFunction,
-  importObjectKeyPathToFunction
+  importedFunctionDescriptor
 ) {
-  const importedFunctionDescriptor = getFunctionFromKeyPath(
-    asbindInstance.typeDescriptor.importedFunctions,
-    importObjectKeyPathToFunction
-  );
-  if (!importedFunctionDescriptor) {
-    console.warn(
-      `Unexpected function ${importObjectKeyPathToFunction.join(
-        "."
-      )} on import object, using pass-through.`
-    );
-    return importedFunction;
-  }
-
   // Grab type converter functions according to the type descriptor
   const argumentConverterFunctions = importedFunctionDescriptor.parameters.map(
     getAscToJsConverterForType
@@ -69,14 +53,8 @@ export function bindImportFunction(
 export function bindExportFunction(
   asbindInstance,
   exportedFunction,
-  exportFunctionKey
+  exportedFunctionDescriptor
 ) {
-  const exportedFunctionDescriptor =
-    asbindInstance.typeDescriptor.exportedFunctions[exportFunctionKey];
-  if (!exportedFunctionDescriptor) {
-    throw Error(`Unknown function ${exportFunctionKey}`);
-  }
-
   // Grab type converter functions according to the type descriptor
   const argumentConverterFunctions = exportedFunctionDescriptor.parameters.map(
     getJsToAscConverterForType

test/tests/import-on-prototype/asc.ts

@@ -0,0 +1,6 @@
+declare function thing(): string;
+declare const otherThing: u32;
+
+export function add(): string {
+  return otherThing.toString() + thing();
+}

test/tests/import-on-prototype/test.js

@@ -0,0 +1,19 @@
+describe("as-bind", function() {
+  it("should handle the prototype chain on the imports object", async function() {
+    debugger;
+    const asc = {
+      otherThing: new WebAssembly.Global({ value: "i32", mutable: false }, 4)
+    };
+    // This function will be “seen” by the WebAssembly engine as an imported
+    // function but is not visible via Object.keys() or similar.
+    Object.setPrototypeOf(asc, {
+      thing() {
+        return "2";
+      }
+    });
+    assert(asc.thing() === "2");
+    assert(Object.keys(asc).join(",") === "otherThing");
+    const instance = await AsBind.instantiate(this.rawModule, { asc });
+    assert(instance.exports.add() === "42");
+  });
+});