Add support for enum literals

Author: g. nicholas d'andrea

packages/parse-mapping-lookup/src/ast.ts

@@ -174,19 +174,31 @@ export interface HexLiteral extends Literal {
   value: string;
 }
 
+export interface EnumLiteral extends Literal {
+  type: "enum";
+  value: {
+    contract?: Identifier;
+    enumeration: Identifier;
+    member: Identifier;
+  };
+}
+
 export const {
   booleanLiteral,
   numberLiteral,
   stringLiteral,
   hexLiteral,
+  enumLiteral
 } = LiteralGenerics.makeConstructors<{
   boolean: BooleanLiteral;
   number: NumberLiteral;
   string: StringLiteral;
   hex: HexLiteral;
+  enum: EnumLiteral;
 }>({
   boolean: {},
   number: {},
   string: {},
-  hex: {}
+  hex: {},
+  enum: {}
 } as const);

packages/parse-mapping-lookup/src/parser.spec.ts

@@ -9,7 +9,8 @@ import {
   numberLiteral,
   stringLiteral,
   booleanLiteral,
-  hexLiteral
+  hexLiteral,
+  enumLiteral
 } from "@truffle/parse-mapping-lookup/ast";
 
 const testCases = [
@@ -106,6 +107,47 @@ const testCases = [
   {
     expression: `m[hex"deadbee"]`,
     errors: true
+  },
+  {
+    expression: `m[Direction.North]`,
+    result: expression({
+      root: identifier({ name: "m" }),
+      pointer: pointer({
+        path: [
+          indexAccess({
+            index: enumLiteral({
+              value: {
+                enumeration: identifier({ name: "Direction" }),
+                member: identifier({ name: "North" })
+              }
+            })
+          })
+        ]
+      })
+    })
+  },
+  {
+    expression: `m[Geography.Direction.North]`,
+    result: expression({
+      root: identifier({ name: "m" }),
+      pointer: pointer({
+        path: [
+          indexAccess({
+            index: enumLiteral({
+              value: {
+                contract: identifier({ name: "Geography" }),
+                enumeration: identifier({ name: "Direction" }),
+                member: identifier({ name: "North" })
+              }
+            })
+          })
+        ]
+      })
+    })
+  },
+  {
+    expression: `m[North]`,
+    errors: true
   }
 ];
 

packages/parse-mapping-lookup/src/parser.ts

@@ -15,6 +15,7 @@ import {
   qthen,
   map,
   exactly,
+  maybe,
   many,
   manyBetween,
   stringify,
@@ -31,6 +32,7 @@ import {
   stringLiteral,
   booleanLiteral,
   hexLiteral,
+  enumLiteral,
   memberLookup,
   pointer
 } from "./ast";
@@ -123,11 +125,38 @@ const hexLiteralP = digit(16).pipe(exactly(2)).pipe(
   map(value => hexLiteral({ value: `0x${value}` }))
 );
 
+const enumLiteralP = identifierP.pipe(
+  then(
+    string(".").pipe(
+      qthen(identifierP)
+    ),
+    string(".").pipe(
+      qthen(identifierP),
+      maybe()
+    )
+  ),
+).pipe(
+  map(args => {
+    if (args[2]) {
+      const [contract, enumeration, member] = args;
+      return enumLiteral({
+        value: { contract, enumeration, member }
+      });
+    } else {
+      const [enumeration, member] = args;
+      return enumLiteral({
+        value: { enumeration, member }
+      });
+    }
+  })
+);
+
 const literalP = numberLiteralP.pipe(
   or(
     stringLiteralP,
     booleanLiteralP,
-    hexLiteralP
+    hexLiteralP,
+    enumLiteralP
   )
 );