# HG changeset patch
# User Gilles Duboscq <duboscq@ssw.jku.at>
# Date 1397232992 -7200
# Node ID 4a162f0b59d75a25474760a318d88fcf93689793
# Parent  140bd4b4e3c6efc34061edca06602843034e0651
Simplify NodePredicates (use overrides instead of if cascades)

diff -r 140bd4b4e3c6 -r 4a162f0b59d7 graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicate.java
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicate.java	Fri Apr 11 18:01:21 2014 +0200
+++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicate.java	Fri Apr 11 18:16:32 2014 +0200
@@ -23,20 +23,21 @@
 package com.oracle.graal.graph.iterators;
 
 import com.oracle.graal.graph.*;
+import com.oracle.graal.graph.iterators.NodePredicates.*;
 
 public interface NodePredicate {
 
     boolean apply(Node n);
 
     default NodePredicate and(NodePredicate np) {
-        return NodePredicates.and(this, np);
+        return new AndPredicate(this, np);
     }
 
     default NodePredicate or(NodePredicate np) {
-        return NodePredicates.or(this, np);
+        return new OrPredicate(this, np);
     }
 
     default NodePredicate negate() {
-        return NodePredicates.not(this);
+        return new NotPredicate(this);
     }
 }
diff -r 140bd4b4e3c6 -r 4a162f0b59d7 graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicates.java
--- a/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicates.java	Fri Apr 11 18:01:21 2014 +0200
+++ b/graal/com.oracle.graal.graph/src/com/oracle/graal/graph/iterators/NodePredicates.java	Fri Apr 11 18:16:32 2014 +0200
@@ -52,60 +52,7 @@
     }
 
     public static NodePredicate not(NodePredicate a) {
-        if (a == TAUTOLOGY) {
-            return FALSE;
-        }
-        if (a == FALSE) {
-            return TAUTOLOGY;
-        }
-        if (a == IS_NULL) {
-            return IS_NOT_NULL;
-        }
-        if (a == IS_NOT_NULL) {
-            return IS_NULL;
-        }
-        if (a instanceof NotPredicate) {
-            return ((NotPredicate) a).a;
-        }
-        if (a instanceof PositiveTypePredicate) {
-            return new NegativeTypePredicate((PositiveTypePredicate) a);
-        }
-        if (a instanceof NegativeTypePredicate) {
-            return new PositiveTypePredicate((NegativeTypePredicate) a);
-        }
-        if (a instanceof EqualsPredicate) {
-            return new NotEqualsPredicate(((EqualsPredicate) a).u);
-        }
-        if (a instanceof NotEqualsPredicate) {
-            return new EqualsPredicate(((NotEqualsPredicate) a).u);
-        }
-        return new NotPredicate(a);
-    }
-
-    public static NodePredicate and(NodePredicate a, NodePredicate b) {
-        if (a == TAUTOLOGY) {
-            return b;
-        }
-        if (b == TAUTOLOGY) {
-            return a;
-        }
-        if (a == FALSE || b == FALSE) {
-            return FALSE;
-        }
-        return new AndPredicate(a, b);
-    }
-
-    public static NodePredicate or(NodePredicate a, NodePredicate b) {
-        if (a == FALSE) {
-            return b;
-        }
-        if (b == FALSE) {
-            return a;
-        }
-        if (a == TAUTOLOGY || b == TAUTOLOGY) {
-            return TAUTOLOGY;
-        }
-        return new OrPredicate(a, b);
+        return a.negate();
     }
 
     public static NegativeTypePredicate isNotA(Class<? extends Node> clazz) {
@@ -126,28 +73,52 @@
         return new NegativeTypePredicate(iface);
     }
 
-    private static final class TautologyPredicate implements NodePredicate {
+    static final class TautologyPredicate implements NodePredicate {
 
         @Override
         public boolean apply(Node n) {
             return true;
         }
+
+        public NodePredicate and(NodePredicate np) {
+            return np;
+        }
+
+        public NodePredicate negate() {
+            return FALSE;
+        }
+
+        public NodePredicate or(NodePredicate np) {
+            return this;
+        }
     }
 
-    private static final class FalsePredicate implements NodePredicate {
+    static final class FalsePredicate implements NodePredicate {
 
         @Override
         public boolean apply(Node n) {
             return false;
         }
+
+        public NodePredicate and(NodePredicate np) {
+            return this;
+        }
+
+        public NodePredicate negate() {
+            return TAUTOLOGY;
+        }
+
+        public NodePredicate or(NodePredicate np) {
+            return np;
+        }
     }
 
-    private static final class AndPredicate implements NodePredicate {
+    static final class AndPredicate implements NodePredicate {
 
         private final NodePredicate a;
         private final NodePredicate b;
 
-        private AndPredicate(NodePredicate a, NodePredicate b) {
+        AndPredicate(NodePredicate a, NodePredicate b) {
             this.a = a;
             this.b = b;
         }
@@ -158,11 +129,11 @@
         }
     }
 
-    private static final class NotPredicate implements NodePredicate {
+    static final class NotPredicate implements NodePredicate {
 
         private final NodePredicate a;
 
-        private NotPredicate(NodePredicate n) {
+        NotPredicate(NodePredicate n) {
             this.a = n;
         }
 
@@ -170,14 +141,18 @@
         public boolean apply(Node n) {
             return !a.apply(n);
         }
+
+        public NodePredicate negate() {
+            return a;
+        }
     }
 
-    private static final class OrPredicate implements NodePredicate {
+    static final class OrPredicate implements NodePredicate {
 
         private final NodePredicate a;
         private final NodePredicate b;
 
-        private OrPredicate(NodePredicate a, NodePredicate b) {
+        OrPredicate(NodePredicate a, NodePredicate b) {
             this.a = a;
             this.b = b;
         }
@@ -188,27 +163,35 @@
         }
     }
 
-    private static final class IsNullPredicate implements NodePredicate {
+    static final class IsNullPredicate implements NodePredicate {
 
         @Override
         public boolean apply(Node n) {
             return n == null;
         }
+
+        public NodePredicate negate() {
+            return IS_NOT_NULL;
+        }
     }
 
-    private static final class IsNotNullPredicate implements NodePredicate {
+    static final class IsNotNullPredicate implements NodePredicate {
 
         @Override
         public boolean apply(Node n) {
             return n != null;
         }
+
+        public NodePredicate negate() {
+            return IS_NULL;
+        }
     }
 
-    private static final class EqualsPredicate implements NodePredicate {
+    static final class EqualsPredicate implements NodePredicate {
 
         private final Node u;
 
-        public EqualsPredicate(Node u) {
+        EqualsPredicate(Node u) {
             this.u = u;
         }
 
@@ -216,13 +199,17 @@
         public boolean apply(Node n) {
             return u == n;
         }
+
+        public NodePredicate negate() {
+            return new NotEqualsPredicate(u);
+        }
     }
 
-    private static final class NotEqualsPredicate implements NodePredicate {
+    static final class NotEqualsPredicate implements NodePredicate {
 
         private final Node u;
 
-        public NotEqualsPredicate(Node u) {
+        NotEqualsPredicate(Node u) {
             this.u = u;
         }
 
@@ -230,6 +217,10 @@
         public boolean apply(Node n) {
             return u != n;
         }
+
+        public NodePredicate negate() {
+            return new EqualsPredicate(u);
+        }
     }
 
     public static final class PositiveTypePredicate implements NodePredicate {
@@ -237,7 +228,7 @@
         private final Class<?> type;
         private PositiveTypePredicate or;
 
-        public PositiveTypePredicate(Class<?> type) {
+        PositiveTypePredicate(Class<?> type) {
             this.type = type;
         }
 
@@ -261,6 +252,10 @@
             }
             return this;
         }
+
+        public NodePredicate negate() {
+            return new NegativeTypePredicate(this);
+        }
     }
 
     public static final class NegativeTypePredicate implements NodePredicate {
@@ -268,7 +263,7 @@
         private final Class<?> type;
         private NegativeTypePredicate nor;
 
-        public NegativeTypePredicate(Class<?> type) {
+        NegativeTypePredicate(Class<?> type) {
             this.type = type;
         }
 
@@ -292,5 +287,9 @@
             }
             return this;
         }
+
+        public NodePredicate negate() {
+            return new PositiveTypePredicate(this);
+        }
     }
 }