Unify code a bit

Author: surma

lib/asbind-instance/asbind-instance.js

@@ -7,23 +7,17 @@ import { isReservedExportKey } from "./reserved-export-keys";
 const SECTION_NAME = "as-bind_bindings";
 
 // Need to traverse the importObject and bind all import functions
-function traverseObjectAndRunCallbackForFunctions(baseObject, keys, callback) {
-  if (!baseObject) {
+function traverseObjectAndRunCallback(obj, callback, keys = [], baseObj = obj) {
+  if (!obj) {
     return;
   }
-
-  Object.keys(baseObject).forEach(baseObjectKey => {
-    if (typeof baseObject[baseObjectKey] === "function") {
-      // Call the callback
-      callback(baseObject, keys, baseObjectKey);
-    } else if (typeof baseObject[baseObjectKey] === "object") {
-      traverseObjectAndRunCallbackForFunctions(
-        baseObject[baseObjectKey],
-        [...keys, baseObjectKey],
-        callback
-      );
+  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);
+  }
 }
 
 async function compileStreaming(source) {
@@ -86,46 +80,43 @@ export default class AsbindInstance {
   }
 
   async _instantiate(source, importObject) {
+    this.importObject = importObject;
     this.module = await compileStreaming(source);
+
     this._validate();
     this.typeDescriptor = extractTypeDescriptor(this.module);
-    // Bind our import function
-    this._instantiateBindImportFunctions(importObject);
-
+    this._instantiateBindImportFunctions();
     // Instantiate the module through the loader
     this.loadedModule = await asbindInstantiate(this.module, this.importObject);
-
-    // Bind our unbound exports
     this._instantiateBindUnboundExports();
   }
 
   _instantiateSync(source, importObject) {
+    this.importObject = importObject;
     this.module = new WebAssembly.Module(source);
+
     this._validate();
     this.typeDescriptor = extractTypeDescriptor(this.module);
     this._instantiateBindImportFunctions(importObject);
-
     this.loadedModule = asbindInstantiateSync(this.module, this.importObject);
     this._instantiateBindUnboundExports();
   }
 
   _instantiateBindImportFunctions(importObject) {
-    // Set our import object, as we will need it to store type caching
-    this.importObject = importObject;
-
     // Need to traverse the importObject and bind all import functions
-    traverseObjectAndRunCallbackForFunctions(
+    traverseObjectAndRunCallback(
       this.importObject,
-      [],
-      (baseObject, keys, baseObjectKey) => {
-        // Wrap the original key, but then expose a new key for the unbound import
-        let importFunction = baseObject[baseObjectKey];
-        baseObject[`__asbind_unbound_${baseObjectKey}`] = importFunction;
-        baseObject[baseObjectKey] = bindImportFunction(
-          this,
-          this.importObject,
-          [...keys, baseObjectKey]
-        );
+      (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
+          );
+        }
       }
     );
   }
@@ -135,19 +126,23 @@ export default class AsbindInstance {
     const unboundExports = this.loadedModule.exports;
     this.exports = {};
 
-    Object.keys(unboundExports).forEach(unboundExportKey => {
-      if (
-        typeof unboundExports[unboundExportKey] === "function" &&
-        !isReservedExportKey(unboundExportKey)
-      ) {
-        // Wrap the export
-        this.exports[unboundExportKey] = bindExportFunction(
-          this,
-          unboundExportKey
-        );
-      } else {
-        this.exports[unboundExportKey] = unboundExports[unboundExportKey];
+    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;
+        }
       }
-    });
+    );
   }
 }

lib/asbind-instance/bind-function.js

@@ -146,18 +146,14 @@ function getJsToAscConverterForType(typeName) {
   return getConverterForType(typeName)?.jsToAsc;
 }
 
-// Function that takes in an asbindInstance, and importObject, and the path to the import function on the object
+// 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: () => {}}})
-// To find the importFunction, wrap it, re-assign it to the improt Object, and allow it to access itself later.
 export function bindImportFunction(
   asbindInstance,
-  importObject,
+  importedFunction,
   importObjectKeyPathToFunction
 ) {
-  const importedFunction = getFunctionFromKeyPath(
-    importObject,
-    importObjectKeyPathToFunction
-  );
   const importedFunctionDescriptor = getFunctionFromKeyPath(
     asbindInstance.typeDescriptor.importedFunctions,
     importObjectKeyPathToFunction
@@ -166,13 +162,16 @@ export function bindImportFunction(
     throw Error(`Unknown function ${importObjectKeyPathToFunction.join(".")}`);
   }
 
+  // Grab type converter functions according to the type descriptor
   const argumentConverterFunctions = importedFunctionDescriptor.parameters.map(
     getAscToJsConverterForType
   );
   const returnValueConverterFunction = getJsToAscConverterForType(
     importedFunctionDescriptor.returnType
   );
 
+  // Create a wrapper function that applies the correct converter function to arguments and
+  // return value respectively.
   return function(...args) {
     if (args.length != argumentConverterFunctions.length) {
       throw Error(
@@ -197,22 +196,27 @@ export function bindImportFunction(
 
 // Function that takes in an asbind instance, and the key to the export function on the
 // abindInstance.exports object, to be wrapped and then re-assigned to the asbindInstance.exports.
-export function bindExportFunction(asbindInstance, exportFunctionKey) {
-  const exportedFunction =
-    asbindInstance.loadedModule.exports[exportFunctionKey];
+export function bindExportFunction(
+  asbindInstance,
+  exportedFunction,
+  exportFunctionKey
+) {
   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
   );
   const returnValueConverterFunction = getAscToJsConverterForType(
     exportedFunctionDescriptor.returnType
   );
 
+  // Create a wrapper function that applies the correct converter function to arguments and
+  // return value respectively.
   return (...args) => {
     if (args.length != argumentConverterFunctions.length) {
       throw Error(

lib/asbind-instance/reserved-export-keys.js

@@ -19,10 +19,6 @@ export const RESERVED_RUNTIME_EXPORT_KEYS = [
 ];
 
 export function isReservedExportKey(key) {
-  if (key.startsWith("__asbind")) {
-    return true;
-  }
-
   return RESERVED_RUNTIME_EXPORT_KEYS.some(reservedKey => {
     if (typeof reservedKey === "string") {
       return reservedKey === key;