From b3d3dd71e6f576de36a3e5c18f1fcd6ce6933f17 Mon Sep 17 00:00:00 2001
From: jonmv <venstad@gmail.com>
Date: Sun, 2 Oct 2022 21:23:24 +0200
Subject: Revert "Merge pull request #24257 from
 vespa-engine/bratseth/boolean-optimize-primitives-only"

This reverts commit 4a1ca594e4cf3810974696ce970f5a161ec099eb, reversing
changes made to 62928f4d8b7571c4b10fedffc56b762f57b6b2ca.
---
 .../BooleanExpressionTransformer.java                 | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

(limited to 'config-model/src/main/java/com/yahoo/schema/expressiontransforms')

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 25cd7fe7bd2..ad050d4ca63 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
@@ -36,12 +36,12 @@ public class BooleanExpressionTransformer extends ExpressionTransformer<Transfor
             node = transformChildren(composite, context);
 
         if (node instanceof OperationNode arithmetic)
-            node = transformBooleanArithmetics(arithmetic, context);
+            node = transformBooleanArithmetics(arithmetic);
 
         return node;
     }
 
-    private ExpressionNode transformBooleanArithmetics(OperationNode node, TransformContext context) {
+    private ExpressionNode transformBooleanArithmetics(OperationNode node) {
         Iterator<ExpressionNode> child = node.children().iterator();
 
         // Transform in precedence order:
@@ -51,25 +51,24 @@ public class BooleanExpressionTransformer extends ExpressionTransformer<Transfor
             Operator op = it.next();
             if ( ! stack.isEmpty()) {
                 while (stack.size() > 1 && ! op.hasPrecedenceOver(stack.peek().op)) {
-                    popStack(stack, context);
+                    popStack(stack);
                 }
             }
             stack.push(new ChildNode(op, child.next()));
         }
         while (stack.size() > 1)
-            popStack(stack, context);
+            popStack(stack);
         return stack.getFirst().child;
     }
 
-    private void popStack(Deque<ChildNode> stack, TransformContext context) {
+    private void popStack(Deque<ChildNode> stack) {
         ChildNode rhs = stack.pop();
         ChildNode lhs = stack.peek();
 
-        boolean primitives = isPrimitive(lhs.child, context) && isPrimitive(rhs.child, context);
         ExpressionNode combination;
-        if (primitives && rhs.op == Operator.and)
+        if (rhs.op == Operator.and)
             combination = andByIfNode(lhs.child, rhs.child);
-        else if (primitives && rhs.op == Operator.or)
+        else if (rhs.op == Operator.or)
             combination = orByIfNode(lhs.child, rhs.child);
         else {
             combination = resolve(lhs, rhs);
@@ -78,10 +77,6 @@ public class BooleanExpressionTransformer extends ExpressionTransformer<Transfor
         lhs.child = combination;
     }
 
-    private boolean isPrimitive(ExpressionNode node, TransformContext context) {
-        return node.type(context.types()).rank() == 0;
-    }
-
     private static OperationNode resolve(ChildNode left, ChildNode right) {
         if (! (left.child instanceof OperationNode) && ! (right.child instanceof OperationNode))
             return new OperationNode(left.child, right.op, right.child);
-- 
cgit v1.2.3