modify eq tests

Author: noti0na1

library/src/dotty/DottyPredef.scala

@@ -51,18 +51,4 @@ object DottyPredef {
   def[T] (x: T|Null) nn: x.type & T =
     if (x == null) throw new NullPointerException("tried to cast away nullability, but value is null")
     else x.asInstanceOf[x.type & T]
-
-  /** Reference equality where the receiver is a nullable union.
-   *  Note that if the receiver `r` is a reference type (e.g. `String`), then `r.eq` will invoke the
-   *  `eq` method in `AnyRef`.
-   */
-  def (x: AnyRef|Null) eq(y: AnyRef|Null): Boolean =
-    x.asInstanceOf[AnyRef] eq y.asInstanceOf[AnyRef]
-
-  /** Reference disequality where the receiver is a nullable union.
-   *  Note that if the receiver `r` is a reference type (e.g. `String`), then `r.ne` will invoke the
-   *  `ne` method in `AnyRef`.
-   */
-  def (x: AnyRef|Null) ne(y: AnyRef|Null): Boolean =
-    x.asInstanceOf[AnyRef] ne y.asInstanceOf[AnyRef]
 }

tests/explicit-nulls/neg/eq.scala

@@ -3,24 +3,31 @@ class Foo {
   // Null itself
   val x0: Null = null
   x0 == null
+  x0 != null
   null == x0
   null == null
 
   // Nullable types: OK
   val x1: String|Null = null
   x1 == null
   null == x1
+  x1 == x0
+  x1 != x0
+  x0 == x1
 
   // Reference types, even non-nullable ones: OK.
   // Allowed as an escape hatch.
   val x2: String = "hello"
-  x2 != null 
+  x2 != null
   x2 == null
   null == x2
 
   // Value types: not allowed.
-  1 == null    // error
-  null == 1    // error
-  true == null // error
-  null == true // error
+  1 == null     // error
+  null != 0     // error
+  null == 0     // error
+  true == null  // error
+  null == false // error
+  'a' == null   // error
+  null == 'b'   // error
 }

tests/explicit-nulls/neg/eq2.scala

@@ -1,15 +1,18 @@
-
 // Test that we can't compare for equality `null` and
 // classes that derive from AnyVal.
 class Foo(x: Int) extends AnyVal
 
 class Bar {
   val foo: Foo = new Foo(15)
-  if (foo == null) {} // error
+  if (foo == null) {} // error: Values of types Null and Foo cannot be compared
   if (null == foo) {} // error
+  if (foo != null) {} // error
+  if (null != foo) {} // error
 
   // To test against null, make the type nullable.
   val foo2: Foo|Null = foo
-  if (foo2 == null) {} 
+  if (foo2 == null) {}
   if (null == foo2) {}
+  if (foo2 != null) {}
+  if (null != foo2) {}
 }

tests/explicit-nulls/pos/ref-eq.scala

@@ -0,0 +1,24 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    val x: String|Null = ""
+    val y: String|Null = null
+    val z: String = ""
+
+    assert(x == x)
+    assert(x == "")
+    assert("" == x)
+    assert(x == z)
+    assert(z == x)
+    assert(x != "xx")
+    assert(x != y)
+    assert(y == y)
+
+    assert(x != null)
+    assert(null != x)
+    assert(y == null)
+    assert(null == y)
+    assert(null == null)
+  }
+}