- Added method "ne" in class AnyRef

12 files changed, 95 insertions, 6 deletions

diff --git a/sources/scala/tools/scalai/Compiler.java b/sources/scala/tools/scalai/Compiler.java
index bf3fd326a9..d51d957097 100644
--- a/sources/scala/tools/scalai/Compiler.java
+++ b/sources/scala/tools/scalai/Compiler.java
@@ -179,6 +179,10 @@ public class Compiler {
         Override eq_override = Override.empty().insert(definitions.OBJECT_EQ);
         environment.insertOverride(definitions.OBJECT_EQ, eq_override);
 
+        environment.insertFunction(definitions.OBJECT_NE, Function.Ne);
+        Override ne_override = Override.empty().insert(definitions.OBJECT_NE);
+        environment.insertOverride(definitions.OBJECT_NE, ne_override);
+
         environment.insertFunction(definitions.ANY_EQEQ, Function.EqEq);
         Override eqeq_override = Override.empty().insert(definitions.ANY_EQEQ);
         environment.insertOverride(definitions.ANY_EQEQ, eqeq_override);
diff --git a/sources/scala/tools/scalai/Evaluator.java b/sources/scala/tools/scalai/Evaluator.java
index 1d2f0017c6..a96d60de69 100644
--- a/sources/scala/tools/scalai/Evaluator.java
+++ b/sources/scala/tools/scalai/Evaluator.java
@@ -315,6 +315,10 @@ public class Evaluator {
             assert args.length == 1 : Debug.show(args);
             return object == args[0] ? Boolean.TRUE : Boolean.FALSE;
 
+        case Ne:
+            assert args.length == 1 : Debug.show(args);
+            return object != args[0] ? Boolean.TRUE : Boolean.FALSE;
+
         case EqEq:
             assert args.length == 1 : Debug.show(args);
             return object == null ? new Boolean(args[0] == null) : new Boolean(object.equals(args[0])); // !!!
diff --git a/sources/scala/tools/scalai/Function.java b/sources/scala/tools/scalai/Function.java
index 3057a46f14..f799e6d30a 100644
--- a/sources/scala/tools/scalai/Function.java
+++ b/sources/scala/tools/scalai/Function.java
@@ -32,6 +32,7 @@ public class Function {
     public case Throw;
     public case StringPlus;
     public case Eq;
+    public case Ne;
     public case EqEq;
     public case BangEq;
     public case HashCode;
@@ -73,6 +74,9 @@ public class Function {
         case Eq:
             return "Eq";
 
+        case Ne:
+            return "Ne";
+
         case EqEq:
             return "EqEq";
 
diff --git a/sources/scalac/atree/ATreeFromSTree.java b/sources/scalac/atree/ATreeFromSTree.java
index 43944c47c2..83e50eb7e1 100644
--- a/sources/scalac/atree/ATreeFromSTree.java
+++ b/sources/scalac/atree/ATreeFromSTree.java
@@ -364,6 +364,10 @@ public class ATreeFromSTree {
             assert targs.length == 0 && vargs.length == 1: tree;
             return make.EQ(tree, ATypeKind.REF, object, expression(vargs[0]));
 
+        case ANYNI:
+            assert targs.length == 0 && vargs.length == 1: tree;
+            return make.NE(tree, ATypeKind.REF, object, expression(vargs[0]));
+
         case ANYEQ:
             Symbol lf = newLocal(tree, definitions.ANY_TYPE());
             Symbol rg = newLocal(tree, definitions.ANY_TYPE());
@@ -481,6 +485,7 @@ public class ATreeFromSTree {
         }
         if (clasz == definitions.OBJECT_CLASS) {
             addGenerator(definitions.OBJECT_EQ, Generator.ANYID);
+            addGenerator(definitions.OBJECT_NE, Generator.ANYNI);
             addGenerator(definitions.OBJECT_SYNCHRONIZED, Generator.SYNCHRONIZED);
         }
         if (clasz == definitions.STRING_CLASS) {
@@ -535,6 +540,7 @@ public class ATreeFromSTree {
     /** Code generators for primitive methods. */
     private static class Generator {
         case ANYID;
+        case ANYNI;
         case ANYEQ;
         case ANYNE;
         case ISAS(boolean cast);
diff --git a/sources/scalac/backend/Primitive.java b/sources/scalac/backend/Primitive.java
index 5cc6f49106..2c55a68dc8 100644
--- a/sources/scalac/backend/Primitive.java
+++ b/sources/scalac/backend/Primitive.java
@@ -47,6 +47,7 @@ public class Primitive {
 
     // Comparison operations
     public case ID;                           // x eq y
+    public case NI;                           // x ne y
     public case EQ;                           // x == y
     public case NE;                           // x != y
     public case LT;                           // x < y
diff --git a/sources/scalac/backend/Primitives.java b/sources/scalac/backend/Primitives.java
index 76869c2f78..b2cef185dd 100644
--- a/sources/scalac/backend/Primitives.java
+++ b/sources/scalac/backend/Primitives.java
@@ -668,6 +668,7 @@ public class Primitives {
 
         // scala.Object
         addPrimitive(defs.OBJECT_EQ, Primitive.ID);
+        addPrimitive(defs.OBJECT_NE, Primitive.NI);
         addPrimitive(defs.OBJECT_SYNCHRONIZED, Primitive.SYNCHRONIZED);
 
         // scala.String
diff --git a/sources/scalac/backend/jvm/GenJVM.java b/sources/scalac/backend/jvm/GenJVM.java
index 9ba9b67939..037b66b423 100644
--- a/sources/scalac/backend/jvm/GenJVM.java
+++ b/sources/scalac/backend/jvm/GenJVM.java
@@ -348,7 +348,7 @@ public class GenJVM {
                     generatedType = resType;
                     break;
 
-                case ID:
+                case ID: case NI:
                 case EQ: case NE: case LT: case LE: case GE: case GT:
                 case ZNOT: case ZOR: case ZAND:
                     JCode.Label falseLabel = ctx.code.newLabel();
@@ -711,7 +711,7 @@ public class GenJVM {
                 Tree[] allArgs = extractPrimitiveArgs((Tree.Apply)tree);
 
                 switch (prim) {
-                case ID: case EQ: case NE:
+                case ID: case NI: case EQ: case NE:
                     assert allArgs.length == 2;
                     Tree unbox1 = unbox(allArgs[0]);
                     Tree unbox2 = unbox(allArgs[1]);
@@ -864,6 +864,9 @@ public class GenJVM {
         if (prim == Primitive.ID) {
             if (when) ctx.code.emitIF_ACMPEQ(target);
             else ctx.code.emitIF_ACMPNE(target);
+        } else if (prim == Primitive.NI) {
+            if (!when) ctx.code.emitIF_ACMPEQ(target);
+            else ctx.code.emitIF_ACMPNE(target);
         } else {
             // Comparison between two references. We inline the code
             // for the predefined (and final) "=="/"!=" operators,
@@ -1193,7 +1196,7 @@ public class GenJVM {
     protected boolean isJumpingPrimitive(Symbol sym) {
         if (prims.isPrimitive(sym)) {
             switch (prims.getPrimitive(sym)) {
-            case ID   : case EQ  : case NE   :
+            case ID   : case NI  : case EQ   : case NE :
             case LT   : case LE  : case GE   : case GT :
             case ZNOT : case ZOR : case ZAND :
                 return true;
@@ -1228,7 +1231,7 @@ public class GenJVM {
             case ZARRAY_LENGTH : case BARRAY_LENGTH : case SARRAY_LENGTH :
             case CARRAY_LENGTH : case IARRAY_LENGTH : case LARRAY_LENGTH :
             case FARRAY_LENGTH : case DARRAY_LENGTH : case OARRAY_LENGTH :
-            case IS : case AS : case ID :
+            case IS : case AS : case ID : case NI :
             case CONCAT : case THROW : case SYNCHRONIZED:
             case B2B: case B2S: case B2C: case B2I: case B2L: case B2F: case B2D:
             case S2B: case S2S: case S2C: case S2I: case S2L: case S2F: case S2D:
diff --git a/sources/scalac/backend/msil/GenMSIL.java b/sources/scalac/backend/msil/GenMSIL.java
index eae9c7cf4a..ec490359d9 100644
--- a/sources/scalac/backend/msil/GenMSIL.java
+++ b/sources/scalac/backend/msil/GenMSIL.java
@@ -1011,7 +1011,7 @@ public final class GenMSIL {
 	case ADD: case SUB: case MUL: case DIV: case MOD:
 	case OR: case XOR: case AND:
 	case LSL: case LSR: case ASR:
-	case ID: case EQ: case NE: case LT: case LE: case GT: case GE:
+	case ID: case NI: case EQ: case NE: case LT: case LE: case GT: case GE:
 	case ZNOT: case ZOR: case ZAND:
 	case IS: case AS:
 	case CONCAT:
@@ -1246,7 +1246,7 @@ public final class GenMSIL {
 	case ID: case EQ: // FIXME?: should ID be treated as EQ?
 	    res =  items.CondItem(Test.Binary(Test.EQ, toType), null, null);
 	    break;
-	case NE:
+	case NI: case NE: // FIXME?: should NI be treated as NE?
 	    res = items.CondItem(Test.Binary(Test.NE, toType), null, null);
 	    break;
 	case LT:
diff --git a/sources/scalac/symtab/Definitions.java b/sources/scalac/symtab/Definitions.java
index 00e37cc2a4..a6286853da 100644
--- a/sources/scalac/symtab/Definitions.java
+++ b/sources/scalac/symtab/Definitions.java
@@ -330,6 +330,7 @@ public class Definitions {
 
     /** Some java.lang.Object methods */
     public final Symbol OBJECT_EQ;
+    public final Symbol OBJECT_NE;
     public final Symbol OBJECT_SYNCHRONIZED;
 
     /** Some java.lang.String methods */
@@ -877,10 +878,13 @@ public class Definitions {
         // add members to java.lang.Object
         OBJECT_EQ =
             newMethod(OBJECT_CLASS, Names.eq, Modifiers.FINAL);
+        OBJECT_NE =
+            newMethod(OBJECT_CLASS, Names.ne, Modifiers.FINAL);
         OBJECT_SYNCHRONIZED =
             newMethod(OBJECT_CLASS, Names.synchronized_, Modifiers.FINAL);
 
         initMethod(OBJECT_EQ, new Type[]{ANYREF_TYPE()}, boolean_TYPE());
+        initMethod(OBJECT_NE, new Type[]{ANYREF_TYPE()}, boolean_TYPE());
         Symbol OBJECT_SYNCHRONIZED_TPARAM =
             newTParam(OBJECT_SYNCHRONIZED,0,ANY_TYPE());
         Symbol OBJECT_SYNCHRONIZED_VPARAM =
diff --git a/sources/scalac/util/Names.java b/sources/scalac/util/Names.java
index f1d15c414d..7bfc3d17f0 100644
--- a/sources/scalac/util/Names.java
+++ b/sources/scalac/util/Names.java
@@ -197,6 +197,7 @@ public class Names {
     public static final Name _match = Name.fromString("match");
     public static final Name map = Name.fromString("map");
     public static final Name n = Name.fromString("n");
+    public static final Name ne = Name.fromString("ne");
     public static final Name nobinding = Name.fromString("nobinding");
     public static final Name next = Name.fromString("next");
     public static final Name newArray = Name.fromString("newArray");
diff --git a/test/files/run/runtime.check b/test/files/run/runtime.check
index bbe28252c7..990a087da0 100644
--- a/test/files/run/runtime.check
+++ b/test/files/run/runtime.check
@@ -43,3 +43,22 @@ M0
 
 >>> Test2
 
+<<< Test3
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+Ok
+>>> Test3
+
diff --git a/test/files/run/runtime.scala b/test/files/run/runtime.scala
index 135480aa6d..64f78db7c6 100644
--- a/test/files/run/runtime.scala
+++ b/test/files/run/runtime.scala
@@ -133,6 +133,47 @@ object Test2Test {
 }
 
 //############################################################################
+// Test 3 - Methods eq and ne
+
+object Test3Test {
+
+  class Foo { override def equals(that: Any) = throw new Error("abort"); }
+
+  def check(expected: Boolean, actual1: Boolean, actual2: Boolean): Unit =
+    System.out.println(
+      if ((actual1 == expected) && (actual2 == !expected)) "Ok" else "KO: "
+        + "expected: " + expected + " - " + (!expected) + ", "
+        + "found: " + actual1 + " - " + actual1);
+
+  def main(args: Array[String]): Unit = {
+    val foo1: AnyRef = null;
+    val foo2: AnyRef = new Foo();
+    val foo3: AnyRef = new Foo();
+
+    check(true , null eq null, null ne null);
+    check(true , null eq foo1, null ne foo1);
+    check(false, null eq foo2, null ne foo2);
+    check(false, null eq foo3, null ne foo3);
+
+    check(true , foo1 eq null, foo1 ne null);
+    check(true , foo1 eq foo1, foo1 ne foo1);
+    check(false, foo1 eq foo2, foo1 ne foo2);
+    check(false, foo1 eq foo3, foo1 ne foo3);
+
+    check(false, foo2 eq null, foo2 ne null);
+    check(false, foo2 eq foo1, foo2 ne foo1);
+    check(true , foo2 eq foo2, foo2 ne foo2);
+    check(false, foo2 eq foo3, foo2 ne foo3);
+
+    check(false, foo3 eq null, foo3 ne null);
+    check(false, foo3 eq foo1, foo3 ne foo1);
+    check(false, foo3 eq foo2, foo3 ne foo2);
+    check(true , foo3 eq foo3, foo3 ne foo3);
+  }
+
+}
+
+//############################################################################
 // Main
 
 object Test  {
@@ -158,6 +199,7 @@ object Test  {
     test("Test0"  , Test0Test.main(args));
     test("Test1"  , Test1Test.main(args));
     test("Test2"  , Test2Test.main(args));
+    test("Test3"  , Test3Test.main(args));
 
     if (errors > 0) {
       System.out.println();