Refactor Expression Formatter

Author: rcosta358

liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/formatter/ExpressionFormatter.java

@@ -40,27 +40,24 @@ private String formatExpression(Expression expression) {
         return expression.accept(this);
     }
 
-    private String formatParentheses(Expression child, boolean shouldWrap) {
-        Expression expression = unwrapGroup(child);
+    private String formatExpression(Expression expression, boolean shouldWrap) {
+        expression = unwrapGroup(expression);
         if (shouldWrap)
             return "(" + formatExpression(expression) + ")";
         return formatExpression(expression);
     }
 
-    private String formatLeftOperand(Expression parent, Expression child) {
-        return formatParentheses(child, needsLeftParentheses(parent, child));
-    }
-
-    private String formatRightOperand(BinaryExpression parent, Expression child) {
-        return formatParentheses(child, needsRightParentheses(parent, child));
+    private String formatOperand(Expression parent, Expression child, boolean rightOperand) {
+        child = unwrapGroup(child);
+        return formatExpression(child, needsParentheses(parent, child, rightOperand));
     }
 
     private String formatCondition(Expression child) {
-        return formatParentheses(child, unwrapGroup(child) instanceof Ite);
+        return formatExpression(child, unwrapGroup(child) instanceof Ite);
     }
 
     private String formatArguments(List<Expression> args) {
-        return args.stream().map(expression -> formatParentheses(expression, false)).collect(Collectors.joining(", "));
+        return args.stream().map(expression -> formatExpression(expression, false)).collect(Collectors.joining(", "));
     }
 
     private Expression unwrapGroup(Expression expression) {
@@ -69,35 +66,28 @@ private Expression unwrapGroup(Expression expression) {
         return expression;
     }
 
-    private boolean needsParentheses(Expression parent, Expression child) {
-        return ExpressionPrecedence.of(child).isLowerThan(ExpressionPrecedence.of(parent));
-    }
-
-    private boolean needsLeftParentheses(Expression parent, Expression child) {
-        if (needsParentheses(parent, child))
+    private boolean needsParentheses(Expression parent, Expression child, boolean rightOperand) {
+        ExpressionPrecedence parentPrecedence = ExpressionPrecedence.of(parent);
+        ExpressionPrecedence childPrecedence = ExpressionPrecedence.of(child);
+        if (childPrecedence.isLowerThan(parentPrecedence))
             return true;
-
-        Expression unwrappedChild = unwrapGroup(child);
-        if (ExpressionPrecedence.of(unwrappedChild) != ExpressionPrecedence.of(parent))
+        if (childPrecedence != parentPrecedence)
             return false;
 
-        return parent instanceof BinaryExpression binary && isRightAssociative(binary.getOperator())
-                && unwrappedChild instanceof BinaryExpression;
-    }
+        if (parent instanceof BinaryExpression parentBinary && child instanceof BinaryExpression childBinary)
+            return needsBinaryParentheses(parentBinary, childBinary, rightOperand);
 
-    private boolean needsRightParentheses(BinaryExpression parent, Expression child) {
-        if (needsParentheses(parent, child))
-            return true;
+        if (parent instanceof UnaryExpression parentUnary && child instanceof UnaryExpression childUnary)
+            return parentUnary.getOp().equals("-") && childUnary.getOp().equals("-");
 
-        Expression unwrappedChild = unwrapGroup(child);
-        if (ExpressionPrecedence.of(unwrappedChild) != ExpressionPrecedence.of(parent))
-            return false;
+        return false;
+    }
 
-        if (unwrappedChild instanceof BinaryExpression right)
+    private boolean needsBinaryParentheses(BinaryExpression parent, BinaryExpression child, boolean rightOperand) {
+        if (rightOperand)
             return !isRightAssociative(parent.getOperator())
-                    && (!isAssociative(parent.getOperator()) || !parent.getOperator().equals(right.getOperator()));
-
-        return false;
+                    && (!isAssociative(parent.getOperator()) || !parent.getOperator().equals(child.getOperator()));
+        return isRightAssociative(parent.getOperator());
     }
 
     private boolean isAssociative(String operator) {
@@ -115,8 +105,8 @@ public String visitAliasInvocation(AliasInvocation alias) {
 
     @Override
     public String visitBinaryExpression(BinaryExpression exp) {
-        return formatLeftOperand(exp, exp.getFirstOperand()) + " " + exp.getOperator() + " "
-                + formatRightOperand(exp, exp.getSecondOperand());
+        return formatOperand(exp, exp.getFirstOperand(), false) + " " + exp.getOperator() + " "
+                + formatOperand(exp, exp.getSecondOperand(), true);
     }
 
     @Override
@@ -132,7 +122,7 @@ public String visitGroupExpression(GroupExpression exp) {
     @Override
     public String visitIte(Ite ite) {
         return formatCondition(ite.getCondition()) + " ? " + formatCondition(ite.getThen()) + " : "
-                + formatLeftOperand(ite, ite.getElse());
+                + formatOperand(ite, ite.getElse(), true);
     }
 
     @Override
@@ -167,10 +157,7 @@ public String visitLiteralString(LiteralString lit) {
 
     @Override
     public String visitUnaryExpression(UnaryExpression exp) {
-        Expression child = unwrapGroup(exp.getExpression());
-        boolean nestedMinus = child instanceof UnaryExpression unary && exp.getOp().equals("-")
-                && unary.getOp().equals("-");
-        return exp.getOp() + formatParentheses(child, needsParentheses(exp, child) || nestedMinus);
+        return exp.getOp() + formatOperand(exp, exp.getExpression(), true);
     }
 
     @Override