refactor index

packages/ast/src/definitions.js

@@ -272,15 +272,17 @@ defineType("Elem", {
   unionType: ["Node"],
   fields: {
     table: {
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     },
     offset: {
       array: true,
       type: "Instruction"
     },
     funcs: {
       array: true,
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     }
   }
 });
@@ -289,7 +291,8 @@ defineType("IndexInFuncSection", {
   unionType: ["Node"],
   fields: {
     index: {
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     }
   }
 });
@@ -308,7 +311,8 @@ defineType("TypeInstruction", {
   fields: {
     id: {
       maybe: true,
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     },
     functype: {
       type: "Signature"
@@ -320,7 +324,9 @@ defineType("Start", {
   unionType: ["Node"],
   fields: {
     index: {
-      type: "Index"
+      assertNodeType: true,
+      type: "Index",
+      assertNodeType: true,
     }
   }
 });
@@ -404,7 +410,8 @@ defineType("Table", {
     elements: {
       array: true,
       optional: true,
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     }
   }
 });
@@ -417,7 +424,8 @@ defineType("Memory", {
     },
     id: {
       maybe: true,
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     }
   }
 });
@@ -456,7 +464,8 @@ defineType("ModuleExportDescr", {
       type: "ExportDescrType"
     },
     id: {
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     }
   }
 });
@@ -555,6 +564,7 @@ defineType("CallInstruction", {
       value: "call"
     },
     index: {
+      assertNodeType: true,
       type: "Index"
     },
     instrArgs: {
@@ -599,7 +609,8 @@ defineType("Func", {
   fields: {
     name: {
       maybe: true,
-      type: "Index"
+      type: "Index",
+      assertNodeType: true,
     },
     signature: {
       type: "SignatureOrTypeRef"
@@ -620,4 +631,19 @@ defineType("Func", {
   }
 });
 
+defineType("Index", {
+  unionType: ["Node"],
+  fields: {
+    index: {
+      maybe: true,
+      type: "Idx"
+    },
+    identifier: {
+      assertNodeType: true,
+      maybe: true,
+      type: "Identifier"
+    }
+  }
+});
+
 module.exports = definitions;

packages/ast/src/index.js

@@ -10,7 +10,9 @@ export {
   indexLiteral,
   memIndexLiteral,
   instruction,
-  objectInstruction
+  objectInstruction,
+  indexOfIndex,
+  indexOfIdentifier
 } from "./node-helpers.js";
 
 export { traverse } from "./traverse";

packages/ast/src/node-helpers.js

@@ -1,5 +1,7 @@
 // @flow
 
+import { assert } from "mamacro";
+
 const {
   parse32F,
   parse64F,
@@ -10,7 +12,15 @@ const {
   isInfLiteral
 } = require("@webassemblyjs/wast-parser/lib/number-literals");
 
-import { longNumberLiteral, floatLiteral, numberLiteral, instr } from "./nodes";
+import {
+  assertNumberLiteral,
+  assertIdentifier,
+  longNumberLiteral,
+  floatLiteral,
+  numberLiteral,
+  instr,
+  index
+} from "./nodes";
 
 export function numberLiteralFromRaw(
   rawValue: number | string,
@@ -113,3 +123,17 @@ export function memIndexLiteral(value: number): Memidx {
   const x: U32Literal = numberLiteralFromRaw(value, "u32");
   return x;
 }
+
+export function indexOfIndex(n: NumberLiteral) {
+  console.log(n.type);
+  assertNumberLiteral(n);
+
+  return index(n, null);
+}
+
+export function indexOfIdentifier(n: Identifer) {
+  console.log(n.type);
+  assertIdentifier(n);
+
+  return index(null, n);
+}

packages/ast/src/nodes.js

@@ -384,6 +384,10 @@ export function elem(
   offset: Array<Instruction>,
   funcs: Array<Index>
 ): Elem {
+  assert(
+    table.type === "Index",
+    "Argument table must be of type Index, given: " + table.type
+  );
   assert(typeof offset === "object" && typeof offset.length !== "undefined");
 
   assert(typeof funcs === "object" && typeof funcs.length !== "undefined");
@@ -399,6 +403,11 @@ export function elem(
 }
 
 export function indexInFuncSection(index: Index): IndexInFuncSection {
+  assert(
+    index.type === "Index",
+    "Argument index must be of type Index, given: " + index.type
+  );
+
   const node: IndexInFuncSection = {
     type: "IndexInFuncSection",
     index
@@ -420,6 +429,13 @@ export function typeInstruction(
   id: ?Index,
   functype: Signature
 ): TypeInstruction {
+  if (id !== null && id !== undefined) {
+    assert(
+      id.type === "Index",
+      "Argument id must be of type Index, given: " + id.type
+    );
+  }
+
   const node: TypeInstruction = {
     type: "TypeInstruction",
     id,
@@ -430,6 +446,11 @@ export function typeInstruction(
 }
 
 export function start(index: Index): Start {
+  assert(
+    index.type === "Index",
+    "Argument index must be of type Index, given: " + index.type
+  );
+
   const node: Start = {
     type: "Start",
     index
@@ -543,6 +564,13 @@ export function table(
 }
 
 export function memory(limits: Limit, id: ?Index): Memory {
+  if (id !== null && id !== undefined) {
+    assert(
+      id.type === "Index",
+      "Argument id must be of type Index, given: " + id.type
+    );
+  }
+
   const node: Memory = {
     type: "Memory",
     limits,
@@ -593,6 +621,11 @@ export function moduleExportDescr(
   exportType: ExportDescrType,
   id: Index
 ): ModuleExportDescr {
+  assert(
+    id.type === "Index",
+    "Argument id must be of type Index, given: " + id.type
+  );
+
   const node: ModuleExportDescr = {
     type: "ModuleExportDescr",
     exportType,
@@ -720,6 +753,11 @@ export function callInstruction(
   index: Index,
   instrArgs?: Array<Expression>
 ): CallInstruction {
+  assert(
+    index.type === "Index",
+    "Argument index must be of type Index, given: " + index.type
+  );
+
   if (instrArgs !== null && instrArgs !== undefined) {
     assert(
       typeof instrArgs === "object" && typeof instrArgs.length !== "undefined"
@@ -778,6 +816,13 @@ export function func(
   isExternal?: boolean,
   metadata?: FuncMetadata
 ): Func {
+  if (name !== null && name !== undefined) {
+    assert(
+      name.type === "Index",
+      "Argument name must be of type Index, given: " + name.type
+    );
+  }
+
   assert(typeof body === "object" && typeof body.length !== "undefined");
 
   if (isExternal !== null && isExternal !== undefined) {
@@ -805,6 +850,24 @@ export function func(
   return node;
 }
 
+export function index(index: ?Idx, identifier: ?Identifier): Index {
+  if (identifier !== null && identifier !== undefined) {
+    assert(
+      identifier.type === "Identifier",
+      "Argument identifier must be of type Identifier, given: " +
+        identifier.type
+    );
+  }
+
+  const node: Index = {
+    type: "Index",
+    index,
+    identifier
+  };
+
+  return node;
+}
+
 export const isModule = isTypeOf("Module");
 
 export const isModuleMetadata = isTypeOf("ModuleMetadata");
@@ -885,6 +948,8 @@ export const isByteArray = isTypeOf("ByteArray");
 
 export const isFunc = isTypeOf("Func");
 
+export const isIndex = isTypeOf("Index");
+
 export const isNode = (node: Node) =>
   isModule(node) ||
   isModuleMetadata(node) ||
@@ -925,7 +990,8 @@ export const isNode = (node: Node) =>
   isCallInstruction(node) ||
   isCallIndirectInstruction(node) ||
   isByteArray(node) ||
-  isFunc(node);
+  isFunc(node) ||
+  isIndex(node);
 
 export const isBlock = (node: Node) =>
   isLoopInstruction(node) || isBlockInstruction(node) || isFunc(node);
@@ -1039,6 +1105,8 @@ export const assertByteArray = assertTypeOf("ByteArray");
 
 export const assertFunc = assertTypeOf("Func");
 
+export const assertIndex = assertTypeOf("Index");
+
 export const unionTypesMap = {
   Module: ["Node"],
   ModuleMetadata: ["Node"],
@@ -1079,7 +1147,8 @@ export const unionTypesMap = {
   CallInstruction: ["Node", "Instruction"],
   CallIndirectInstruction: ["Node", "Instruction"],
   ByteArray: ["Node"],
-  Func: ["Node", "Block"]
+  Func: ["Node", "Block"],
+  Index: ["Node"]
 };
 
 export const nodeAndUnionTypes = [
@@ -1123,6 +1192,7 @@ export const nodeAndUnionTypes = [
   "CallIndirectInstruction",
   "ByteArray",
   "Func",
+  "Index",
   "Node",
   "Block",
   "Instruction",

packages/ast/src/types/basic.js

@@ -25,16 +25,14 @@ type Memidx = U32Literal;
 type Globalidx = U32Literal;
 type Localidx = U32Literal;
 type Labelidx = U32Literal;
-
-type Index =
+type Idx =
   | Typeidx
   | Funcidx
   | Tableidx
   | Memidx
   | Globalidx
   | Localidx
-  | Labelidx
-  | Identifier; // WAST shorthand
+  | Labelidx;
 
 type SignatureOrTypeRef = Index | Signature;
 

packages/ast/src/types/nodes.js

@@ -43,7 +43,8 @@ type Node =
   | CallInstruction
   | CallIndirectInstruction
   | ByteArray
-  | Func;
+  | Func
+  | Index;
 
 type Block = LoopInstruction | BlockInstruction | Func;
 
@@ -367,3 +368,10 @@ type Func = {
   isExternal?: boolean,
   metadata?: FuncMetadata
 };
+
+type Index = {
+  ...BaseNode,
+  type: "Index",
+  index: ?Idx,
+  identifier: ?Identifier
+};

packages/ast/test/traverse.js

@@ -292,7 +292,7 @@ describe("AST traverse", () => {
 
       it("should remove export in module", () => {
         const root = t.module("test", [
-          t.moduleExport("a", t.moduleExportDescr("Func", t.indexLiteral(0)))
+          t.moduleExport("a", t.moduleExportDescr("Func", t.indexOfIndex(t.indexLiteral(0))))
         ]);
 
         traverse(root, {