Add ExpressionPrinter for Pretty Printing

rcosta358 · rcosta358 · commit 0aa749a5dd3c · 2026-03-31T20:09:59.000+01:00
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/AliasInvocation.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/AliasInvocation.java
@@ -2,8 +2,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
-
 import liquidjava.diagnostics.errors.LJError;
 import liquidjava.rj_language.visitors.ExpressionVisitor;
 
@@ -31,7 +29,7 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {
 
     @Override
     public String toString() {
-        return name + "(" + getArgs().stream().map(Expression::toString).collect(Collectors.joining(", ")) + ")";
+        return ExpressionPrinter.print(this);
     }
 
     @Override
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/BinaryExpression.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/BinaryExpression.java
@@ -40,26 +40,9 @@ public boolean isArithmeticOperation() {
         return !isLogicOperation() && !isBooleanOperation();
     }
 
-    private boolean isAssociative() {
-        return op.equals("&&") || op.equals("||") || op.equals("+") || op.equals("*");
-    }
-
-    @Override
-    protected Precedence getPrecedence() {
-        return Precedence.fromOperator(op);
-    }
-
-    private String formatRightOperand(Expression operand) {
-        if (operand.getPrecedence() == getPrecedence() && operand instanceof BinaryExpression right)
-            if (!isAssociative() || !op.equals(right.getOperator()))
-                return parenthesize(operand);
-
-        return formatChild(operand);
-    }
-
     @Override
     public String toString() {
-        return formatChild(getFirstOperand()) + " " + op + " " + formatRightOperand(getSecondOperand());
+        return ExpressionPrinter.print(this);
     }
 
     @Override
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/Expression.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/Expression.java
@@ -36,39 +36,6 @@ public abstract class Expression {
 
     public abstract String toString();
 
-    protected enum Precedence {
-        TERNARY, IMPLICATION, OR, AND, COMPARISON, ADDITIVE, MULTIPLICATIVE, PREFIX, ATOMIC;
-
-        private boolean isLowerThan(Precedence other) {
-            return ordinal() < other.ordinal();
-        }
-
-        protected static Precedence fromOperator(String op) {
-            return switch (op) {
-            case "-->" -> IMPLICATION;
-            case "||" -> OR;
-            case "&&" -> AND;
-            case "==", "!=", ">=", ">", "<=", "<" -> COMPARISON;
-            case "+", "-" -> ADDITIVE;
-            case "*", "/", "%" -> MULTIPLICATIVE;
-            default -> ATOMIC;
-            };
-        }
-    }
-
-    protected Precedence getPrecedence() {
-        return Precedence.ATOMIC;
-    }
-
-    protected String parenthesize(Expression expression) {
-        return "(" + expression.toString() + ")";
-    }
-
-    protected String formatChild(Expression child) {
-        boolean needsParentheses = child.getPrecedence().isLowerThan(getPrecedence());
-        return needsParentheses ? parenthesize(child) : child.toString();
-    }
-
     List<Expression> children = new ArrayList<>();
 
     public void addChild(Expression e) {
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/ExpressionPrinter.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/ExpressionPrinter.java
@@ -0,0 +1,166 @@
+package liquidjava.rj_language.ast;
+
+import java.util.stream.Collectors;
+
+import liquidjava.diagnostics.errors.LJError;
+import liquidjava.rj_language.visitors.ExpressionVisitor;
+import liquidjava.utils.Utils;
+
+public class ExpressionPrinter implements ExpressionVisitor<String> {
+
+    private enum Precedence {
+        TERNARY, IMPLICATION, OR, AND, COMPARISON, ADDITIVE, MULTIPLICATIVE, PREFIX, ATOMIC;
+
+        private boolean isLowerThan(Precedence other) {
+            return ordinal() < other.ordinal();
+        }
+    }
+
+    public static String print(Expression expression) {
+        return new ExpressionPrinter().render(expression);
+    }
+
+    private String render(Expression expression) {
+        return expression.accept(this);
+    }
+
+    private String renderChild(Expression child) {
+        if (child instanceof GroupExpression group)
+            return "(" + render(group.getExpression()) + ")";
+        return render(child);
+    }
+
+    private String renderOperand(Expression parent, Expression child) {
+        if (needsParentheses(parent, child))
+            return "(" + render(child) + ")";
+        return renderChild(child);
+    }
+
+    private String renderRightOperand(BinaryExpression parent, Expression child) {
+        if (needsRightParentheses(parent, child))
+            return "(" + render(child) + ")";
+        return renderChild(child);
+    }
+
+    private String renderConditionOperand(Expression child) {
+        if (child instanceof Ite)
+            return "(" + render(child) + ")";
+        return renderChild(child);
+    }
+
+    private boolean needsParentheses(Expression parent, Expression child) {
+        if (precedence(child).isLowerThan(precedence(parent)))
+            return true;
+        return false;
+    }
+
+    private boolean needsRightParentheses(BinaryExpression parent, Expression child) {
+        if (needsParentheses(parent, child))
+            return true;
+
+        if (precedence(child) != precedence(parent))
+            return false;
+
+        if (child instanceof BinaryExpression right)
+            return !isAssociative(parent.getOperator()) || !parent.getOperator().equals(right.getOperator());
+
+        return false;
+    }
+
+    private Precedence precedence(Expression expression) {
+        if (expression instanceof GroupExpression group)
+            return precedence(group.getExpression());
+        if (expression instanceof Ite)
+            return Precedence.TERNARY;
+        if (expression instanceof UnaryExpression)
+            return Precedence.PREFIX;
+        if (expression instanceof BinaryExpression binary)
+            return precedence(binary.getOperator());
+        return Precedence.ATOMIC;
+    }
+
+    private Precedence precedence(String operator) {
+        return switch (operator) {
+        case "-->" -> Precedence.IMPLICATION;
+        case "||" -> Precedence.OR;
+        case "&&" -> Precedence.AND;
+        case "==", "!=", ">=", ">", "<=", "<" -> Precedence.COMPARISON;
+        case "+", "-" -> Precedence.ADDITIVE;
+        case "*", "/", "%" -> Precedence.MULTIPLICATIVE;
+        default -> Precedence.ATOMIC;
+        };
+    }
+
+    private boolean isAssociative(String operator) {
+        return operator.equals("&&") || operator.equals("||") || operator.equals("+") || operator.equals("*");
+    }
+
+    @Override
+    public String visitAliasInvocation(AliasInvocation alias) {
+        return alias.getName() + "(" + alias.getArgs().stream().map(this::renderChild).collect(Collectors.joining(", "))
+                + ")";
+    }
+
+    @Override
+    public String visitBinaryExpression(BinaryExpression exp) {
+        return renderOperand(exp, exp.getFirstOperand()) + " " + exp.getOperator() + " "
+                + renderRightOperand(exp, exp.getSecondOperand());
+    }
+
+    @Override
+    public String visitFunctionInvocation(FunctionInvocation fun) {
+        return Utils.getSimpleName(fun.getName()) + "("
+                + fun.getArgs().stream().map(this::renderChild).collect(Collectors.joining(",")) + ")";
+    }
+
+    @Override
+    public String visitGroupExpression(GroupExpression exp) {
+        return "(" + render(exp.getExpression()) + ")";
+    }
+
+    @Override
+    public String visitIte(Ite ite) {
+        return renderConditionOperand(ite.getCondition()) + " ? " + renderConditionOperand(ite.getThen()) + " : "
+                + renderOperand(ite, ite.getElse());
+    }
+
+    @Override
+    public String visitLiteralInt(LiteralInt lit) {
+        return Integer.toString(lit.getValue());
+    }
+
+    @Override
+    public String visitLiteralLong(LiteralLong lit) {
+        return Long.toString(lit.getValue());
+    }
+
+    @Override
+    public String visitLiteralBoolean(LiteralBoolean lit) {
+        return Boolean.toString(lit.value);
+    }
+
+    @Override
+    public String visitLiteralChar(LiteralChar lit) {
+        return "'" + lit.getValue() + "'";
+    }
+
+    @Override
+    public String visitLiteralReal(LiteralReal lit) {
+        return Double.toString(lit.getValue());
+    }
+
+    @Override
+    public String visitLiteralString(LiteralString lit) {
+        return lit.toString();
+    }
+
+    @Override
+    public String visitUnaryExpression(UnaryExpression exp) {
+        return exp.getOp() + renderOperand(exp, exp.getExpression());
+    }
+
+    @Override
+    public String visitVar(Var var) {
+        return var.getName();
+    }
+}
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/FunctionInvocation.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/FunctionInvocation.java
@@ -2,8 +2,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.stream.Collectors;
-
 import liquidjava.diagnostics.errors.LJError;
 import liquidjava.rj_language.visitors.ExpressionVisitor;
 import liquidjava.utils.Utils;
@@ -37,8 +35,7 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {
 
     @Override
     public String toString() {
-        return Utils.getSimpleName(name) + "("
-                + getArgs().stream().map(Expression::toString).collect(Collectors.joining(",")) + ")";
+        return ExpressionPrinter.print(this);
     }
 
     @Override
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/GroupExpression.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/GroupExpression.java
@@ -21,12 +21,7 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {
     }
 
     public String toString() {
-        return getExpression().toString();
-    }
-
-    @Override
-    protected Precedence getPrecedence() {
-        return getExpression().getPrecedence();
+        return ExpressionPrinter.print(this);
     }
 
     @Override
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/Ite.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/Ite.java
@@ -30,21 +30,9 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {
         return visitor.visitIte(this);
     }
 
-    @Override
-    protected Precedence getPrecedence() {
-        return Precedence.TERNARY;
-    }
-
-    private String formatCondition(Expression operand) {
-        if (operand instanceof Ite)
-            return parenthesize(operand);
-
-        return formatChild(operand);
-    }
-
     @Override
     public String toString() {
-        return formatCondition(getCondition()) + " ? " + formatCondition(getThen()) + " : " + formatChild(getElse());
+        return ExpressionPrinter.print(this);
     }
 
     @Override
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/LiteralString.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/LiteralString.java
@@ -18,6 +18,7 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {
         return visitor.visitLiteralString(this);
     }
 
+    @Override
     public String toString() {
         return value;
     }
diff --git a/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/UnaryExpression.java b/liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/UnaryExpression.java
@@ -27,14 +27,9 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {
         return visitor.visitUnaryExpression(this);
     }
 
-    @Override
-    protected Precedence getPrecedence() {
-        return Precedence.PREFIX;
-    }
-
     @Override
     public String toString() {
-        return op + formatChild(getExpression());
+        return ExpressionPrinter.print(this);
     }
 
     @Override
diff --git a/liquidjava-verifier/src/test/java/liquidjava/rj_language/ast/ExpressionPrinterTest.java b/liquidjava-verifier/src/test/java/liquidjava/rj_language/ast/ExpressionPrinterTest.java
@@ -18,6 +18,8 @@ void printsUnaryWithParenthesesForCompoundOperands() {
 
         assertEquals("x > 0", comparison.toString());
         assertEquals("!(x > 0)", new UnaryExpression("!", comparison).toString());
+        assertEquals("-(-x)",
+                new UnaryExpression("-", new GroupExpression(new UnaryExpression("-", new Var("x")))).toString());
     }
 
     @Test
@@ -33,6 +35,16 @@ void printsBinaryExpressionsWithOperatorPrecedence() {
         assertEquals("b * c * c", new BinaryExpression(product, "*", new Var("c")).toString());
     }
 
+    @Test
+    void preservesExplicitGroupingOnRightHandSide() {
+        Expression groupedSum = new GroupExpression(new BinaryExpression(new Var("b"), "+", new Var("c")));
+        Expression groupedComparison = new GroupExpression(
+                new BinaryExpression(new LiteralInt(1), ">", new LiteralInt(0)));
+
+        assertEquals("a - (b + c)", new BinaryExpression(new Var("a"), "-", groupedSum).toString());
+        assertEquals("x == (1 > 0)", new BinaryExpression(new Var("x"), "==", groupedComparison).toString());
+    }
+
     @Test
     void printsLogicalExpressionsWithNeededParentheses() {
         Expression andExpression = new BinaryExpression(new Var("a"), "&&", new Var("b"));
@@ -58,6 +70,9 @@ void printsTernaryExpressionsWithNeededParentheses() {
         assertEquals("a ? (b ? c : d) : e",
                 new Ite(new Var("a"), new Ite(new Var("b"), new Var("c"), new Var("d")), new Var("e")).toString());
         assertEquals("a ? b : c ? d : e", new Ite(new Var("a"), new Var("b"), nestedElse).toString());
+        assertEquals("(a ? b : c) ? d : e", new Ite(new GroupExpression(ite), new Var("d"), new Var("e")).toString());
+        assertEquals("a ? b : (c ? d : e)",
+                new Ite(new Var("a"), new Var("b"), new GroupExpression(nestedElse)).toString());
         assertEquals("a ? b : c", new Ite(new Var("a"), new Var("b"), new Var("c")).toString());
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -21,12 +21,7 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`public String toString() {`
`24`		`- return getExpression().toString();`
`25`		`- }`
`26`		`-`
`27`		`- @Override`
`28`		`- protected Precedence getPrecedence() {`
`29`		`- return getExpression().getPrecedence();`
	`24`	`+ return ExpressionPrinter.print(this);`
`30`	`25`	`}`
`31`	`26`
`32`	`27`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {`
`18`	`18`	`return visitor.visitLiteralString(this);`
`19`	`19`	`}`
`20`	`20`
	`21`	`+ @Override`
`21`	`22`	`public String toString() {`
`22`	`23`	`return value;`
`23`	`24`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,14 +27,9 @@ public <T> T accept(ExpressionVisitor<T> visitor) throws LJError {`
`27`	`27`	`return visitor.visitUnaryExpression(this);`
`28`	`28`	`}`
`29`	`29`
`30`		`- @Override`
`31`		`- protected Precedence getPrecedence() {`
`32`		`- return Precedence.PREFIX;`
`33`		`- }`
`34`		`-`
`35`	`30`	`@Override`
`36`	`31`	`public String toString() {`
`37`		`- return op + formatChild(getExpression());`
	`32`	`+ return ExpressionPrinter.print(this);`
`38`	`33`	`}`
`39`	`34`
`40`	`35`	`@Override`