Replace value_parser with JISON parser

.gitignore

@@ -7,5 +7,6 @@ src/gen/translate.ts
 src/gen/declarations.ts
 src/lib/souffle/value_parser.ts
 src/lib/souffle/parser/souffle_parser_gen.js
+src/lib/souffle/parser/souffle_value_parser_gen.js
 functors/functors.o
 functors/libfunctors.so

package.json

@@ -17,9 +17,11 @@
         "copy-dl": "cp -r src/lib/analyses dist/lib && cp -r src/lib/detectors dist/lib",
         "copy-functors": "cp -r functors dist/",
         "build-parser": "jison src/lib/souffle/parser/souffle.jison -o src/lib/souffle/parser/souffle_parser_gen.js -m commonjs && cp src/lib/souffle/parser/souffle_parser_gen.js dist/lib/souffle/parser/souffle_parser_gen.js",
+        "build-expr-parser": "jison src/lib/souffle/parser/souffle_value.jison -o src/lib/souffle/parser/souffle_value_parser_gen.js -m commonjs && cp src/lib/souffle/parser/souffle_value_parser_gen.js dist/lib/souffle/parser/souffle_value_parser_gen.js",
         "build-value-parser": "tspegjs -o src/lib/souffle/value_parser.ts  --custom-header-file src/lib/souffle/value_header.ts --allowed-start-rules Value --cache src/lib/souffle/values.pegjs",
+        "build-parsers": "npm run build-parser && npm run build-expr-parser",
         "build-functors": "./scripts/build_functors.sh",
-        "build": "npm run clean && npm run gen-translation-modules && npm run build-value-parser && npm run transpile && npm run build-parser && chmod a+x dist/bin/cli.js && npm run copy-dl && npm run build-functors && npm run copy-functors",
+        "build": "npm run clean && npm run gen-translation-modules && npm run build-value-parser && npm run transpile && npm run build-parsers && chmod a+x dist/bin/cli.js && npm run copy-dl && npm run build-functors && npm run copy-functors",
         "test": "c8 mocha",
         "lint": "eslint src/ test/ --ext=ts",
         "lint:fix": "eslint src/ test/ --ext=ts --fix",

src/lib/souffle/fact.ts

@@ -1,18 +1,95 @@
 import * as sol from "solc-typed-ast";
 import { Relation } from "./relation";
-import { RecordT, SubT, DatalogType, NumberT, SymbolT, AliasT } from "./types";
-import { ParsedFieldVal, parseValue } from "./value_parser";
-import { zip } from "../utils";
+import { RecordT, SubT, DatalogType, NumberT, SymbolT, AliasT, ADTT } from "./types";
+import { parseExpression } from "./parser";
+import * as ast from "./ast";
+
+function getBranch(typ: ADTT, branch: string): [string, Array<[string, DatalogType]>] {
+    const filtered = typ.branches.filter(([name]) => name === branch);
+    sol.assert(
+        filtered.length === 1,
+        `Couldn't find branch hamed {0} in ADT {1}`,
+        branch,
+        typ.name
+    );
+
+    return filtered[0];
+}
+
+/**
+ * Convert a literal Expression AST to a FieldVal.
+ */
+function literalExprToVal(expr: ast.Expression, typ: DatalogType): FieldVal {
+    if (expr instanceof ast.Num) {
+        return expr.value;
+    }
+
+    if (expr instanceof ast.StringLiteral) {
+        return expr.value;
+    }
+
+    if (expr instanceof ast.Nil) {
+        sol.assert(typ instanceof RecordT, ``);
+        return null;
+    }
 
-export type FieldVal = string | number | bigint | { [field: string]: FieldVal } | null;
+    if (expr instanceof ast.RecordLiteral) {
+        sol.assert(typ instanceof RecordT, ``);
+        sol.assert(typ.fields.length === expr.args.length, ``);
+
+        return Object.fromEntries(
+            expr.args.map((_, i) => [
+                typ.fields[i][0],
+                literalExprToVal(expr.args[i], typ.fields[i][1])
+            ])
+        );
+    }
+
+    if (expr instanceof ast.ADTLiteral) {
+        sol.assert(typ instanceof ADTT, ``);
+        const branchT = getBranch(typ, expr.branch);
+
+        return [
+            expr.branch,
+            Object.fromEntries(
+                expr.args.map((_, i) => [
+                    branchT[1][i][0],
+                    literalExprToVal(expr.args[i], branchT[1][i][1])
+                ])
+            )
+        ];
+    }
+
+    throw new Error(`NYI translating ${expr.pp()} of type ${typ.name} to FieldVal`);
+}
+
+export function parseValueInt(source: string, typ: DatalogType): FieldVal {
+    return literalExprToVal(parseExpression(source), typ);
+}
+
+export type RecordVal = { [field: string]: FieldVal };
+export type ADTVal = [string, RecordVal];
+export type FieldVal = string | bigint | number | RecordVal | ADTVal | null;
+
+function isADT(v: FieldVal): v is ADTVal {
+    return v instanceof Array;
+}
+
+function isRecord(v: FieldVal): v is RecordVal {
+    return v instanceof Object && !isADT(v);
+}
 
 // TODO: A lot of functions with very similar structure. Code duplication probably here
 
 function fieldValToJSON(val: FieldVal, typ: DatalogType): any {
-    if (typ === SymbolT || typ == NumberT) {
+    if (typ === SymbolT) {
         return val;
     }
 
+    if (typ == NumberT) {
+        return Number(val);
+    }
+
     if (typ instanceof SubT) {
         return fieldValToJSON(val, typ.parentT);
     }
@@ -26,7 +103,7 @@ function fieldValToJSON(val: FieldVal, typ: DatalogType): any {
             return null;
         }
 
-        sol.assert(val instanceof Object, `Expected an object in fieldValToJSON, not ${val}`);
+        sol.assert(isRecord(val), `Expected a Record in fieldValToJSON, not ${val}`);
         return typ.fields.map(([name, fieldT]) => fieldValToJSON(val[name], fieldT));
     }
 
@@ -55,54 +132,13 @@ export function ppFieldVal(val: FieldVal, typ: DatalogType): string {
             return `nil`;
         }
 
-        sol.assert(val instanceof Object, `Expected an object in ppFieldVal`);
+        sol.assert(isRecord(val), `Expected an object in ppFieldVal`);
         return `[${typ.fields.map(([name, fieldT]) => ppFieldVal(val[name], fieldT)).join(", ")}]`;
     }
 
     throw new Error(`NYI type ${typ.name}`);
 }
 
-export function translateVal(raw: ParsedFieldVal, typ: DatalogType): FieldVal {
-    if (typ === NumberT) {
-        sol.assert(
-            typeof raw === "number",
-            `Expected a number when translating a number, not {0}`,
-            typeof raw
-        );
-        return raw;
-    }
-
-    if (typ === SymbolT) {
-        sol.assert(typeof raw === "string", `Expected a string when translating a symbol`);
-        return raw;
-    }
-
-    if (typ instanceof SubT) {
-        return translateVal(raw, typ.parentT);
-    }
-
-    if (typ instanceof AliasT) {
-        return translateVal(raw, typ.originalT);
-    }
-
-    if (typ instanceof RecordT) {
-        if (raw === null) {
-            return null;
-        }
-
-        sol.assert(raw instanceof Array && raw.length === typ.fields.length, ``);
-
-        return Object.fromEntries(
-            zip(
-                typ.fields.map((x) => x[0]),
-                raw.map((x, i) => translateVal(x, typ.fields[i][1]))
-            )
-        );
-    }
-
-    throw new Error(`NYI type ${typ.name}`);
-}
-
 function parseFieldValFromCsv(val: any, typ: DatalogType): FieldVal {
     if (typ === NumberT) {
         sol.assert(typeof val === "number", `Expected a number`);
@@ -123,7 +159,7 @@ function parseFieldValFromCsv(val: any, typ: DatalogType): FieldVal {
 
     if (typ instanceof RecordT) {
         sol.assert(typeof val === "string", `Expected a string`);
-        return translateVal(parseValue(val), typ);
+        return parseValueInt(val, typ);
     }
 
     throw new Error(`NYI datalog type ${typ}`);
@@ -150,7 +186,7 @@ function parseFieldValFromSQL(val: any, typ: DatalogType): FieldVal {
 
     if (typ instanceof RecordT) {
         if (typeof val === "string") {
-            return translateVal(parseValue(val), typ);
+            return parseValueInt(val, typ);
         }
 
         throw new Error(`NYI parsing record types from ${val}`);

src/lib/souffle/index.ts

@@ -2,4 +2,3 @@ export * from "./instance";
 export * from "./souffle";
 export * from "./types";
 export * from "./relation";
-export { parseValue } from "./value_parser";

src/lib/souffle/parser/index.ts

@@ -1 +1 @@
-export * from "./parser";
+export * from "./parsers";

src/lib/souffle/parser/parsers.ts

@@ -0,0 +1,14 @@
+import * as ast from "../ast";
+
+const ProgramParser = (require("./souffle_parser_gen") as any).Parser;
+const ExprParser = (require("./souffle_value_parser_gen") as any).Parser;
+const programParser = new ProgramParser();
+const exprParser = new ExprParser();
+
+export function parseProgram(s: string): ast.Program {
+    return programParser.parse(s);
+}
+
+export function parseExpression(s: string): ast.Expression {
+    return exprParser.parse(s);
+}