Validate transformed modules

.gitignore

@@ -1,3 +1,4 @@
 *.tgz
 /dist/
+/src/test/out/
 node_modules/

src/index.ts

@@ -234,7 +234,8 @@ class Autodiff {
             fwdTape,
             this.mod.tuple.extract(call, results.length + resultsGrad.length),
           ),
-          this.mod.tuple.make(
+          util.tupleMake(
+            this.mod,
             results.map((_, i) =>
               this.mod.tuple.extract(this.fwdGet(tuple), i),
             ),
@@ -416,7 +417,7 @@ export const autodiff = (mod: binaryen.Module): Gradient[] => {
         null,
         [
           mod.local.set(out, fwdBody),
-          mod.tuple.make([
+          util.tupleMake(mod, [
             ...ad.results.map((_, i) => mod.tuple.extract(ad.fwdGet(out), i)),
             ...ad.resultsGrad.map(() => mod.f64.const(0)),
             util.structNew(
@@ -447,12 +448,16 @@ export const autodiff = (mod: binaryen.Module): Gradient[] => {
           ),
           mod.local.set(
             gradResults,
-            mod.tuple.make(
+            util.tupleMake(
+              mod,
               ad.resultsGrad.map((_, i) => ad.get(ad.paramsGrad.length + i)),
             ),
           ),
           ...ad.bwd.reverse(),
-          mod.tuple.make(ad.paramsGrad.map((_, index) => ad.get(index))),
+          util.tupleMake(
+            mod,
+            ad.paramsGrad.map((_, index) => ad.get(index)),
+          ),
         ],
         bwdResult,
       ),

src/test/index.test.ts

@@ -1,13 +1,26 @@
 import binaryen from "binaryen";
-import { expect, test } from "vitest";
+import path from "path";
+import { beforeAll, expect, test } from "vitest";
 import * as wasmad from "../index.js";
 import * as util from "../util.js";
-import { slurp } from "./util.js";
+import { dir, mkdirp, rmrf, slurp, spit } from "./util.js";
+
+const out = "out";
+
+beforeAll(async () => {
+  await rmrf(out);
+  await mkdirp(out);
+});
+
+const features =
+  binaryen.Features.Multivalue |
+  binaryen.Features.ReferenceTypes |
+  binaryen.Features.GC;
 
 const wat = async (text: string): Promise<Uint8Array> => {
   const mod = binaryen.parseText(text);
   try {
-    mod.setFeatures(binaryen.Features.GC);
+    mod.setFeatures(features);
     return mod.emitBinary();
   } finally {
     mod.dispose();
@@ -57,12 +70,13 @@ interface Names {
 const autodiff = async <T extends AD>(filename: string): Promise<T> => {
   const mod = binaryen.parseText(await slurp(filename));
   try {
-    mod.setFeatures(binaryen.Features.Multivalue);
-    mod.setFeatures(binaryen.Features.GC);
+    mod.setFeatures(features);
+
     const set = new util.Names();
     const n = mod.getNumExports();
     for (let i = 0; i < n; ++i)
       set.add(binaryen.getExportInfo(mod.getExportByIndex(i)).name);
+
     const names = wasmad.autodiff(mod).map((f, i): Names => {
       const name = binaryen.getFunctionInfo(mod.getFunctionByIndex(i)).name;
       const fwdName = binaryen.getFunctionInfo(f.fwd).name;
@@ -75,8 +89,15 @@ const autodiff = async <T extends AD>(filename: string): Promise<T> => {
       mod.addFunctionExport(bwdName, bwd);
       return { name, orig, fwd, bwd };
     });
+
+    const filepath = path.join(out, filename);
+    await spit(filepath, mod.emitText());
+    if (!mod.validate())
+      throw Error(`invalid module: ${path.join(dir, filepath)}`);
+
     const binary = mod.emitBinary();
     const exports = await compile<any>(binary);
+
     const origs: WebAssembly.Exports = {};
     const fwds: WebAssembly.Exports = {};
     const bwds: WebAssembly.Exports = {};

src/test/util.ts

@@ -3,12 +3,20 @@ import path from "path";
 import url from "url";
 import { expect, test } from "vitest";
 
-const dir = path.dirname(url.fileURLToPath(import.meta.url));
+export const dir = path.dirname(url.fileURLToPath(import.meta.url));
+
+export const rmrf = async (dirname: string): Promise<void> => {
+  await fs.rm(path.join(dir, dirname), { recursive: true, force: true });
+};
+
+export const mkdirp = async (dirname: string): Promise<void> => {
+  await fs.mkdir(path.join(dir, dirname), { recursive: true });
+};
 
 export const slurp = async (filename: string): Promise<string> =>
   await fs.readFile(path.join(dir, filename), "utf8");
 
-const spit = async (filename: string, data: string): Promise<void> =>
+export const spit = async (filename: string, data: string): Promise<void> =>
   await fs.writeFile(path.join(dir, filename), data, "utf8");
 
 export const goldenfile = (

src/util.ts

@@ -57,6 +57,19 @@ export const funcIndicesByName = (
   return indices;
 };
 
+/** Like `tuple.make` on `binaryen.Module`, but accepts singletons. */
+export const tupleMake = (
+  mod: binaryen.Module,
+  elements: binaryen.ExpressionRef[],
+): binaryen.ExpressionRef => {
+  switch (elements.length) {
+    case 1:
+      return elements[0];
+    default:
+      return mod.tuple.make(elements);
+  }
+};
+
 type Bool = number;
 
 type Int = number;