Add parser RTT test

src/ast/declarations/rule.ts

@@ -24,7 +24,7 @@ export class Rule extends Declaration {
                 .map(([num, nums]) => `${num}: (${nums.map((x) => `${x}`).join(", ")})`)
                 .join(", ");
         }
-        return `${indent}${this.head.pp()} :- ${this.body.pp()}.${queryPlanStr}`;
+        return `${indent}${this.head.pp()} :- ${this.body.pp().slice(1, -1)}.${queryPlanStr}`;
     }
 
     children(): Iterable<Node> {

src/ast/declarations/subsumption.ts

@@ -25,7 +25,7 @@ export class Subsumption extends Declaration {
                 .join(", ");
         }
 
-        return `${indent}${this.dominatedHead.pp()} <= ${this.dominatingHead.pp()} :- ${this.body.pp()}.${queryPlanStr}`;
+        return `${indent}${this.dominatedHead.pp()} <= ${this.dominatingHead.pp()} :- ${this.body.pp().slice(1, -1)}.${queryPlanStr}`;
     }
 
     children(): Iterable<Node> {

src/ast/expressions/binary.ts

@@ -29,7 +29,7 @@ export class BinaryOperator extends Expression {
     }
 
     pp(): string {
-        return `(${this.left.pp()} ${this.op} ${this.right.pp()})`;
+        return `${this.left.pp()} ${this.op} ${this.right.pp()}`;
     }
 
     children(): Iterable<Node> {

src/ast/expressions/unary.ts

@@ -13,7 +13,7 @@ export class UnaryOperator extends Expression {
     }
 
     pp(): string {
-        return `(${this.op}${this.subExpr.pp()})`;
+        return `${this.op}${this.subExpr.pp()}`;
     }
 
     children(): Iterable<Node> {

src/ast/rules/constraints/comparison.ts

@@ -15,7 +15,7 @@ export class Comparison extends Constraint {
     }
 
     pp(): string {
-        return `(${this.lhs.pp()} ${this.op} ${this.rhs.pp()})`;
+        return `${this.lhs.pp()} ${this.op} ${this.rhs.pp()}`;
     }
 
     children(): Iterable<Node> {

src/index.ts

@@ -1,3 +1,4 @@
 export * from "./instance";
 export * from "./types";
 export * from "./relation";
+export * from "./utils";

test/parser_rtt.spec.ts

@@ -0,0 +1,41 @@
+import expect from "expect";
+import fse from "fs-extra";
+import { searchRecursive } from "../src";
+import { Program } from "../src/ast";
+import { parseProgram } from "../src/parser";
+
+function ppProg(p: Program): string {
+    return p.map((n) => n.pp()).join("\n");
+}
+
+describe(`Parse Round-trip tests`, () => {
+    for (const dl of searchRecursive("test/samples/", (name) => name.endsWith(".dl"))) {
+        describe(`Sample ${dl}`, () => {
+            let contents: string;
+            let prog: Program;
+            let output: string;
+            let reParsedProg: Program;
+
+            beforeAll(() => {
+                contents = fse.readFileSync(dl, { encoding: "utf-8" });
+            });
+
+            it("Parses correctly", () => {
+                expect(() => {
+                    prog = parseProgram(contents);
+                }).not.toThrow();
+            });
+
+            it("Re-parses after outputting correctly", () => {
+                expect(() => {
+                    output = ppProg(prog);
+                    reParsedProg = parseProgram(output);
+                }).not.toThrow();
+            });
+
+            it("Produces an equivalent AST to the original", () => {
+                expect(output).toEqual(ppProg(reParsedProg));
+            });
+        });
+    }
+});