Use ArithmeticNode.resolve instead of creating a new one explicit.

1 files changed, 32 insertions, 2 deletions

diff --git a/config-model/src/main/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformer.java b/config-model/src/main/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformer.java
index 0d3f289b824..8fa4b469590 100644
--- a/config-model/src/main/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformer.java
+++ b/config-model/src/main/java/com/yahoo/schema/expressiontransforms/BooleanExpressionTransformer.java
@@ -15,6 +15,7 @@ import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.Iterator;
 import java.util.List;
+import java.util.ArrayList;
 
 /**
  * Transforms
@@ -69,11 +70,39 @@ public class BooleanExpressionTransformer extends ExpressionTransformer<Transfor
             combination = andByIfNode(lhs.child, rhs.child);
         else if (rhs.op == ArithmeticOperator.OR)
             combination = orByIfNode(lhs.child, rhs.child);
-        else
-            combination = new ArithmeticNode(List.of(lhs.child, rhs.child), List.of(rhs.op));
+        else {
+            combination = resolve(lhs, rhs);
+            lhs.artificial = true;
+        }
         lhs.child = combination;
     }
 
+    private static ArithmeticNode resolve(ChildNode left, ChildNode right) {
+        if ( ! (left.child instanceof ArithmeticNode) && ! (right.child instanceof ArithmeticNode))
+            return new ArithmeticNode(left.child, right.op, right.child);
+
+        // Collapse inserted ArithmeticNodes
+        List<ArithmeticOperator> joinedOps = new ArrayList<>();
+        joinOps(left, joinedOps);
+        joinedOps.add(right.op);
+        joinOps(right, joinedOps);
+        List<ExpressionNode> joinedChildren = new ArrayList<>();
+        joinChildren(left, joinedChildren);
+        joinChildren(right, joinedChildren);
+        return new ArithmeticNode(joinedChildren, joinedOps);
+    }
+
+    private static void joinOps(ChildNode node, List<ArithmeticOperator> joinedOps) {
+        if (node.artificial && node.child instanceof ArithmeticNode arithmeticNode)
+            joinedOps.addAll(arithmeticNode.operators());
+    }
+    private static void joinChildren(ChildNode node, List<ExpressionNode> joinedChildren) {
+        if (node.artificial && node.child instanceof ArithmeticNode arithmeticNode)
+            joinedChildren.addAll(arithmeticNode.children());
+        else
+            joinedChildren.add(node.child);
+    }
+
 
     private IfNode andByIfNode(ExpressionNode a, ExpressionNode b) {
         return new IfNode(a, b, new ConstantNode(new BooleanValue(false)));
@@ -88,6 +117,7 @@ public class BooleanExpressionTransformer extends ExpressionTransformer<Transfor
 
         final ArithmeticOperator op;
         ExpressionNode child;
+        boolean artificial;
 
         public ChildNode(ArithmeticOperator op, ExpressionNode child) {
             this.op = op;