dynamic dispatch instead of map lookups or equality tests

3 files changed, 33 insertions, 38 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala b/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
index 37fff0e1e8..f99ac28e9d 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Primitives.scala
@@ -120,47 +120,50 @@ trait Primitives { self: ICodes =>
 
 
   /** This class represents a test operation. */
-  class TestOp {
+  sealed abstract class TestOp {
 
     /** Returns the negation of this operation. */
-    def negate(): TestOp = this match {
-        case EQ => NE
-        case NE => EQ
-        case LT => GE
-        case GE => LT
-        case LE => GT
-        case GT => LE
-        case _  => throw new RuntimeException("TestOp unknown case")
-    }
+    def negate(): TestOp
 
     /** Returns a string representation of this operation. */
-    override def toString(): String = this match {
-        case EQ =>  "EQ"
-        case NE =>  "NE"
-        case LT =>  "LT"
-        case GE =>  "GE"
-        case LE =>  "LE"
-        case GT =>  "GT"
-        case _  => throw new RuntimeException("TestOp unknown case")
-    }
+    override def toString(): String
   }
+
   /** An equality test */
-  case object EQ extends TestOp
+  case object EQ extends TestOp {
+    def negate() = NE
+    override def toString() = "EQ"
+  }
 
   /** A non-equality test */
-  case object NE extends TestOp
+  case object NE extends TestOp {
+    def negate() = EQ
+    override def toString() = "NE"
+  }
 
   /** A less-than test */
-  case object LT extends TestOp
+  case object LT extends TestOp {
+    def negate() = GE
+    override def toString() = "LT"
+  }
 
   /** A greater-than-or-equal test */
-  case object GE extends TestOp
+  case object GE extends TestOp {
+    def negate() = LT
+    override def toString() = "GE"
+  }
 
   /** A less-than-or-equal test */
-  case object LE extends TestOp
+  case object LE extends TestOp {
+    def negate() = GT
+    override def toString() = "LE"
+  }
 
   /** A greater-than test */
-  case object GT extends TestOp
+  case object GT extends TestOp {
+    def negate() = LE
+    override def toString() = "GT"
+  }
 
   /** This class represents an arithmetic operation. */
   class ArithmeticOp {
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
index 6f54e2d6df..c5b49ceca1 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala
@@ -1449,7 +1449,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
             case CJUMP(success, failure, cond, kind) =>
               if(kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
                 if (nextBlock == success) {
-                  jcode.emitIF_ICMP(conds(negate(cond)), labels(failure))
+                  jcode.emitIF_ICMP(conds(cond.negate()), labels(failure))
                   // .. and fall through to success label
                 } else {
                   jcode.emitIF_ICMP(conds(cond), labels(success))
@@ -1458,7 +1458,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
                 }
               } else if(kind.isRefOrArrayType) { // REFERENCE(_) | ARRAY(_)
                 if (nextBlock == success) {
-                  jcode.emitIF_ACMP(conds(negate(cond)), labels(failure))
+                  jcode.emitIF_ACMP(conds(cond.negate()), labels(failure))
                   // .. and fall through to success label
                 } else {
                   jcode.emitIF_ACMP(conds(cond), labels(success))
@@ -1476,7 +1476,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
                     else jcode.emitDCMPL()
                 }
                 if (nextBlock == success) {
-                  jcode.emitIF(conds(negate(cond)), labels(failure))
+                  jcode.emitIF(conds(cond.negate()), labels(failure))
                   // .. and fall through to success label
                 } else {
                   jcode.emitIF(conds(cond), labels(success));
@@ -1488,7 +1488,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
             case CZJUMP(success, failure, cond, kind) =>
               if(kind.isIntSizedType) { // BOOL, BYTE, CHAR, SHORT, or INT
                 if (nextBlock == success) {
-                  jcode.emitIF(conds(negate(cond)), labels(failure))
+                  jcode.emitIF(conds(cond.negate()), labels(failure))
                 } else {
                   jcode.emitIF(conds(cond), labels(success))
                   if (nextBlock != failure)
@@ -1524,7 +1524,7 @@ abstract class GenJVM extends SubComponent with GenJVMUtil with GenAndroid with
                     else jcode.emitDCMPL()
                 }
                 if (nextBlock == success) {
-                  jcode.emitIF(conds(negate(cond)), labels(failure))
+                  jcode.emitIF(conds(cond.negate()), labels(failure))
                 } else {
                   jcode.emitIF(conds(cond), labels(success))
                   if (nextBlock != failure)
diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMUtil.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMUtil.scala
index 93d3d19ac8..8b08b4dc0d 100644
--- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVMUtil.scala
+++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVMUtil.scala
@@ -54,14 +54,6 @@ trait GenJVMUtil {
       LE -> JExtendedCode.COND_LE,
       GE -> JExtendedCode.COND_GE
     )
-    val negate = immutable.Map[TestOp, TestOp](
-      EQ -> NE,
-      NE -> EQ,
-      LT -> GE,
-      GT -> LE,
-      LE -> GT,
-      GE -> LT
-    )
 
     /** Specialized array conversion to prevent calling
      *  java.lang.reflect.Array.newInstance via TraversableOnce.toArray