Remove Group Expression

liquidjava-verifier/src/main/java/liquidjava/diagnostics/DebugLog.java

@@ -7,7 +7,6 @@
 import liquidjava.rj_language.Predicate;
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Expression;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.utils.Utils;
 import spoon.reflect.cu.SourcePosition;
 import spoon.reflect.reference.CtTypeReference;
@@ -349,10 +348,6 @@ private static String formatConclusion(Predicate p) {
     }
 
     private static void flattenConjunction(Expression e, List<Expression> out) {
-        if (e instanceof GroupExpression g) {
-            flattenConjunction(g.getExpression(), out);
-            return;
-        }
         if (e instanceof BinaryExpression b && "&&".equals(b.getOperator())) {
             flattenConjunction(b.getFirstOperand(), out);
             flattenConjunction(b.getSecondOperand(), out);

liquidjava-verifier/src/main/java/liquidjava/processor/refinement_checker/general_checkers/OperationsChecker.java

@@ -18,7 +18,6 @@
 import liquidjava.rj_language.Predicate;
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Expression;
-import liquidjava.rj_language.ast.GroupExpression;
 import org.apache.commons.lang3.NotImplementedException;
 import spoon.reflect.code.BinaryOperatorKind;
 import spoon.reflect.code.CtAssignment;
@@ -344,7 +343,7 @@ private Predicate getConditionRefinement(CtExpression<Boolean> condition) throws
     }
 
     private Optional<Predicate> unwrapWildcardEquality(Predicate refinement) {
-        Expression expression = unwrapGroupExpression(refinement.getExpression());
+        Expression expression = refinement.getExpression();
         if (expression instanceof BinaryExpression binaryExpression && Ops.EQ.equals(binaryExpression.getOperator())
                 && Keys.WILDCARD.equals(binaryExpression.getFirstOperand().toString())) {
             return Optional.of(new Predicate(binaryExpression.getSecondOperand()));
@@ -360,7 +359,7 @@ private Predicate valueFromRefinement(CtExpression<?> element, Predicate refinem
         if (value.isPresent())
             return value.get();
 
-        Expression expression = unwrapGroupExpression(refinement.getExpression());
+        Expression expression = refinement.getExpression();
         boolean hasWildcard = refinement.getVariableNames().contains(Keys.WILDCARD);
         if (!hasWildcard && !expression.isBooleanExpression())
             return new Predicate(expression);
@@ -376,12 +375,6 @@ private Predicate createFreshValue(CtExpression<?> element, Predicate refinement
         return Predicate.createVar(newName);
     }
 
-    private Expression unwrapGroupExpression(Expression expression) {
-        while (expression instanceof GroupExpression groupExpression)
-            expression = groupExpression.getExpression();
-        return expression;
-    }
-
     /**
      * Retrieves the refinements for the variable write inside unary operation
      *

liquidjava-verifier/src/main/java/liquidjava/rj_language/Predicate.java

@@ -20,7 +20,6 @@
 import liquidjava.rj_language.ast.Enum;
 import liquidjava.rj_language.ast.Expression;
 import liquidjava.rj_language.ast.FunctionInvocation;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralBoolean;
 import liquidjava.rj_language.ast.LiteralChar;
@@ -75,9 +74,6 @@ public Predicate(String ref, CtElement element) throws LJError {
     public Predicate(String ref, CtElement element, String prefix) throws LJError {
         this.prefix = prefix;
         exp = parse(ref, element);
-        if (!(exp instanceof GroupExpression)) {
-            exp = new GroupExpression(exp);
-        }
         exp = resolveStaticFinalConstants(exp, element);
     }
 

liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/Expression.java

@@ -86,9 +86,6 @@ public boolean isBooleanExpression() {
                 || this instanceof FunctionInvocation) {
             return true;
         }
-        if (this instanceof GroupExpression ge) {
-            return ge.getExpression().isBooleanExpression();
-        }
         if (this instanceof BinaryExpression be) {
             return be.isBooleanOperation() || be.isLogicOperation();
         }
@@ -169,7 +166,7 @@ public Expression substituteState(Map<String, Expression> subMap, String[] toCha
                     sub = sub.substitute(new Var(s), v);
                 }
                 // substitute by sub in parent
-                e = new GroupExpression(sub);
+                e = sub;
             }
         }
         e.auxSubstituteState(subMap, toChange);
@@ -191,7 +188,7 @@ private void auxSubstituteState(Map<String, Expression> subMap, String[] toChang
                             sub = sub.substitute(new Var(s), v);
                         }
                         // substitute by sub in parent
-                        setChild(i, (sub instanceof GroupExpression) ? sub : new GroupExpression(sub));
+                        setChild(i, sub);
                     }
                 }
                 exp.auxSubstituteState(subMap, toChange);
@@ -228,7 +225,7 @@ public Expression changeAlias(Map<String, AliasDTO> alias, Context ctx, Factory
                     }
                     sub = sub.substitute(varExp, aliasExp);
                 }
-                e = new GroupExpression(sub);
+                e = sub;
             }
         }
         e.auxChangeAlias(alias, ctx, f);

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

@@ -8,7 +8,6 @@
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Expression;
 import liquidjava.rj_language.ast.FunctionInvocation;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralBoolean;
 import liquidjava.rj_language.ast.LiteralChar;
@@ -41,31 +40,23 @@ private String formatExpression(Expression expression) {
     }
 
     private String formatExpression(Expression expression, boolean shouldWrap) {
-        expression = unwrapGroup(expression);
         if (shouldWrap)
             return "(" + formatExpression(expression) + ")";
         return formatExpression(expression);
     }
 
     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 formatExpression(child, unwrapGroup(child) instanceof Ite);
+        return formatExpression(child, child instanceof Ite);
     }
 
     private String formatArguments(List<Expression> args) {
         return args.stream().map(expression -> formatExpression(expression, false)).collect(Collectors.joining(", "));
     }
 
-    private Expression unwrapGroup(Expression expression) {
-        while (expression instanceof GroupExpression group)
-            expression = group.getExpression();
-        return expression;
-    }
-
     private boolean needsParentheses(Expression parent, Expression child, boolean rightOperand) {
         ExpressionPrecedence parentPrecedence = ExpressionPrecedence.of(parent);
         ExpressionPrecedence childPrecedence = ExpressionPrecedence.of(child);
@@ -120,11 +111,6 @@ public String visitFunctionInvocation(FunctionInvocation fun) {
         return Utils.getSimpleName(fun.getName()) + "(" + formatArguments(fun.getArgs()) + ")";
     }
 
-    @Override
-    public String visitGroupExpression(GroupExpression exp) {
-        return formatExpression(exp.getExpression());
-    }
-
     @Override
     public String visitIte(Ite ite) {
         return formatCondition(ite.getCondition()) + " ? " + formatCondition(ite.getThen()) + " : "

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

@@ -2,7 +2,6 @@
 
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Expression;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.UnaryExpression;
 
@@ -14,8 +13,6 @@ public boolean isLowerThan(ExpressionPrecedence other) {
     }
 
     public static ExpressionPrecedence of(Expression expression) {
-        if (expression instanceof GroupExpression group)
-            return of(group.getExpression());
         if (expression instanceof Ite)
             return TERNARY;
         if (expression instanceof UnaryExpression)

liquidjava-verifier/src/main/java/liquidjava/rj_language/ast/typing/TypeInfer.java

@@ -7,7 +7,6 @@
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Expression;
 import liquidjava.rj_language.ast.FunctionInvocation;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralBoolean;
 import liquidjava.rj_language.ast.LiteralChar;
@@ -51,8 +50,6 @@ else if (e instanceof Ite)
             return boolType(factory);
         else if (e instanceof BinaryExpression)
             return binaryType(ctx, factory, (BinaryExpression) e);
-        else if (e instanceof GroupExpression)
-            return getType(ctx, factory, ((GroupExpression) e).getExpression());
         else if (e instanceof FunctionInvocation)
             return functionType(ctx, (FunctionInvocation) e);
         else if (e instanceof AliasInvocation)

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VCArithmeticSimplification.java

@@ -6,7 +6,6 @@
 import liquidjava.processor.VCImplication;
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Expression;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralInt;
 import liquidjava.rj_language.ast.LiteralReal;
@@ -44,8 +43,6 @@ private Expression simplifyExpression(Expression expression, List<Expression> no
             return simplifyUnary(unary, nonZeroExpressions);
         if (expression instanceof Ite ite)
             return simplifyIte(ite, nonZeroExpressions);
-        if (expression instanceof GroupExpression group)
-            return simplifyGroup(group, nonZeroExpressions);
         return expression.clone();
     }
 
@@ -108,17 +105,6 @@ private Expression simplifyIte(Ite ite, List<Expression> nonZeroExpressions) {
         return new Ite(condition.clone(), thenExpression.clone(), elseExpression.clone());
     }
 
-    /**
-     * Simplifies an expression wrapped in parentheses while preserving the group node
-     */
-    private Expression simplifyGroup(GroupExpression group, List<Expression> nonZeroExpressions) {
-        Expression expression = group.getExpression();
-        Expression simplified = simplifyExpression(expression, nonZeroExpressions);
-        if (!expression.equals(simplified))
-            return new GroupExpression(simplified);
-        return group.clone();
-    }
-
     /**
      * Dispatches a local binary arithmetic identity by operator
      */

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VCFolding.java

@@ -3,7 +3,6 @@
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Enum;
 import liquidjava.rj_language.ast.Expression;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralBoolean;
 import liquidjava.rj_language.ast.LiteralInt;
@@ -33,9 +32,6 @@ private Expression fold(Expression expression) {
             return foldUnary(unary);
         if (expression instanceof Ite ite)
             return foldIte(ite);
-        // (x) -> x
-        if (expression instanceof GroupExpression group && group.getChildren().size() == 1)
-            return group.getExpression().clone();
         return expression.clone();
     }
 

liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VCLogicalSimplification.java

@@ -5,7 +5,6 @@
 
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Expression;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralBoolean;
 import liquidjava.rj_language.ast.UnaryExpression;
@@ -30,8 +29,6 @@ private Expression simplify(Expression expression) {
             return simplifyUnary(unary);
         if (expression instanceof Ite ite)
             return simplifyIte(ite);
-        if (expression instanceof GroupExpression group)
-            return simplifyGroup(group);
         return expression.clone();
     }
 
@@ -94,17 +91,6 @@ private Expression simplifyIte(Ite ite) {
         return new Ite(condition.clone(), thenExpression.clone(), elseExpression.clone());
     }
 
-    /**
-     * Simplifies an expression wrapped in parentheses while preserving the group node
-     */
-    private Expression simplifyGroup(GroupExpression group) {
-        Expression expression = group.getExpression();
-        Expression simplified = simplify(expression);
-        if (!expression.equals(simplified))
-            return new GroupExpression(simplified);
-        return group.clone();
-    }
-
     /**
      * Dispatches a local binary logical identity by operator
      */

liquidjava-verifier/src/main/java/liquidjava/rj_language/visitors/CreateASTVisitor.java

@@ -10,7 +10,6 @@
 import liquidjava.rj_language.ast.Enum;
 import liquidjava.rj_language.ast.Expression;
 import liquidjava.rj_language.ast.FunctionInvocation;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralBoolean;
 import liquidjava.rj_language.ast.LiteralInt;
@@ -96,7 +95,7 @@ private Expression startCreate(ParseTree rc) throws LJError {
 
     private Expression predCreate(ParseTree rc) throws LJError {
         if (rc instanceof PredGroupContext)
-            return new GroupExpression(create(((PredGroupContext) rc).pred()));
+            return create(((PredGroupContext) rc).pred());
         else if (rc instanceof OpLiteralContext)
             return create(((OpLiteralContext) rc).literalExpression());
         else if (rc instanceof OpMinusContext)

liquidjava-verifier/src/main/java/liquidjava/rj_language/visitors/ExpressionVisitor.java

@@ -5,7 +5,6 @@
 import liquidjava.rj_language.ast.BinaryExpression;
 import liquidjava.rj_language.ast.Enum;
 import liquidjava.rj_language.ast.FunctionInvocation;
-import liquidjava.rj_language.ast.GroupExpression;
 import liquidjava.rj_language.ast.Ite;
 import liquidjava.rj_language.ast.LiteralBoolean;
 import liquidjava.rj_language.ast.LiteralChar;
@@ -23,8 +22,6 @@ public interface ExpressionVisitor<T> {
 
     T visitFunctionInvocation(FunctionInvocation fun) throws LJError;
 
-    T visitGroupExpression(GroupExpression exp) throws LJError;
-
     T visitIte(Ite ite) throws LJError;
 
     T visitLiteralInt(LiteralInt lit) throws LJError;
@@ -44,4 +41,4 @@ public interface ExpressionVisitor<T> {
     T visitEnum(Enum en) throws LJError;
 
     T visitVar(Var var) throws LJError;
-}
+}