Refactoring

Author: rcosta358

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

@@ -22,7 +22,8 @@ public static Expression fold(Expression exp) {
         // try to fold the current expression
         if (exp instanceof BinaryExpression) {
             return foldBinaryExpression((BinaryExpression) exp);
-        } else if (exp instanceof UnaryExpression) {
+        }
+        if (exp instanceof UnaryExpression) {
             return foldUnaryExpression((UnaryExpression) exp);
         }
         return exp;
@@ -55,7 +56,7 @@ private static Expression foldBinaryExpression(BinaryExpression binExp) {
         }
 
         // arithmetic operations with real literals
-        else if (left instanceof LiteralReal && right instanceof LiteralReal) {
+        if (left instanceof LiteralReal && right instanceof LiteralReal) {
             double l = ((LiteralReal) left).getValue();
             double r = ((LiteralReal) right).getValue();
             return switch (op) {
@@ -75,7 +76,7 @@ else if (left instanceof LiteralReal && right instanceof LiteralReal) {
         }
 
         // mixed integer and real operations
-        else if ((left instanceof LiteralInt && right instanceof LiteralReal) || (left instanceof LiteralReal && right instanceof LiteralInt)) {
+        if ((left instanceof LiteralInt && right instanceof LiteralReal) || (left instanceof LiteralReal && right instanceof LiteralInt)) {
             double l = left instanceof LiteralInt ? ((LiteralInt) left).getValue() : ((LiteralReal) left).getValue();
             double r = right instanceof LiteralInt ? ((LiteralInt) right).getValue() : ((LiteralReal) right).getValue();
             return switch (op) {
@@ -95,7 +96,7 @@ else if ((left instanceof LiteralInt && right instanceof LiteralReal) || (left i
         }
 
         // boolean operations with boolean literals
-        else if (left instanceof LiteralBoolean && right instanceof LiteralBoolean) {
+        if (left instanceof LiteralBoolean && right instanceof LiteralBoolean) {
             boolean l = ((LiteralBoolean) left).isBooleanTrue();
             boolean r = ((LiteralBoolean) right).isBooleanTrue();
             return switch (op) {

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

@@ -7,7 +7,7 @@
 public class ConstantPropagation {
 
     public static Expression propagate(Expression exp) {
-        Map<String, Expression> substitutions = VariableExtractor.extract(exp);
+        Map<String, Expression> substitutions = VariableCollector.collect(exp);
         return propagateRecursive(exp, substitutions);
     }
 

…a/rj_language/opt/VariableExtractor.java …a/rj_language/opt/VariableCollector.javaliquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VariableExtractor.java renamed to liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VariableCollector.java liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VariableExtractor.java renamed to liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/VariableCollector.java

@@ -10,14 +10,14 @@
 import liquidjava.rj_language.ast.LiteralReal;
 import liquidjava.rj_language.ast.Var;
 
-public class VariableExtractor {
+public class VariableCollector {
 
-    public static Map<String, Expression> extract(Expression exp) {
+    public static Map<String, Expression> collect(Expression exp) {
         Map<String, Expression> assertions = new HashMap<>();
 
         // only extract assertions if the expression contains conjunctions (&&)
         if (containsConjunction(exp)) {
-            extractRecursive(exp, assertions);
+            collectRecursive(exp, assertions);
         }
         return assertions;
     }
@@ -41,20 +41,19 @@ private static boolean containsConjunction(Expression exp) {
         return false;
     }
 
-    private static void extractRecursive(Expression exp, Map<String, Expression> assertions) {
+    private static void collectRecursive(Expression exp, Map<String, Expression> assertions) {
         if (exp instanceof BinaryExpression) {
             BinaryExpression binExp = (BinaryExpression) exp;
             String operator = binExp.getOperator();
 
             if (operator.equals("&&")) {
                 // for conjunctions recursively extract from both sides
-                extractRecursive(binExp.getFirstOperand(), assertions);
-                extractRecursive(binExp.getSecondOperand(), assertions);
+                collectRecursive(binExp.getFirstOperand(), assertions);
+                collectRecursive(binExp.getSecondOperand(), assertions);
             } else if (operator.equals("==")) {
                 // for assertions check if one side is a variable and the other is a literal
                 Expression left = binExp.getFirstOperand();
                 Expression right = binExp.getSecondOperand();
-
                 if (left instanceof Var && isLiteral(right)) {
                     assertions.put(((Var) left).getName(), right);
                 } else if (right instanceof Var && isLiteral(left)) {
@@ -65,7 +64,7 @@ private static void extractRecursive(Expression exp, Map<String, Expression> ass
         // for other expressions, recurse into children
         else if (exp.hasChildren()) {
             for (Expression child : exp.getChildren()) {
-                extractRecursive(child, assertions);
+                collectRecursive(child, assertions);
             }
         }
     }