Add a synthetic RefEq trait for reference equality

Since `Null` is no longer a subtype of `AnyRef`, and
`AnyRef` defines the `eq` and `neq` method, we were no longer
able to do comparisons like `null.eq(s)`.

Fix this by moving `eq` and `neq` to a new synthetic trait
called `RefEq`, which is a supertype of both `Null` and `AnyRef`.

Author: abeln

compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala

@@ -156,13 +156,23 @@ class DottyPrimitives(ctx: Context) {
     addPrimitive(defn.Any_##, HASH)
 
     // java.lang.Object
-    addPrimitive(defn.Object_eq, ID)
-    addPrimitive(defn.Object_ne, NI)
- /*   addPrimitive(defn.Any_==, EQ)
-    addPrimitive(defn.Any_!=, NE)*/
-    addPrimitive(defn.Object_synchronized, SYNCHRONIZED)
-    /*addPrimitive(defn.Any_isInstanceOf, IS)
-    addPrimitive(defn.Any_asInstanceOf, AS)*/
+    if (ctx.settings.YexplicitNulls.value) {
+      // scala.RefEq
+      addPrimitive(defn.RefEq_eq, ID)
+      addPrimitive(defn.RefEq_ne, NI)
+
+      // java.lang.Object
+      addPrimitive(defn.Object_synchronized, SYNCHRONIZED)
+    } else {
+      // java.lang.Object
+      addPrimitive(defn.Object_eq, ID)
+      addPrimitive(defn.Object_ne, NI)
+      /* addPrimitive(defn.Any_==, EQ)
+      addPrimitive(defn.Any_!=, NE) */
+      addPrimitive(defn.Object_synchronized, SYNCHRONIZED)
+      /*addPrimitive(defn.Any_isInstanceOf, IS)
+      addPrimitive(defn.Any_asInstanceOf, AS)*/
+    }
 
     // java.lang.String
     addPrimitive(defn.String_+, CONCAT)

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -286,7 +286,12 @@ class Definitions {
   lazy val ObjectClass: ClassSymbol = {
     val cls = ctx.requiredClass("java.lang.Object")
     assert(!cls.isCompleted, "race for completing java.lang.Object")
-    cls.info = ClassInfo(cls.owner.thisType, cls, AnyClass.typeRef :: Nil, newScope)
+    val parents = if (ctx.settings.YexplicitNulls.value) {
+      AnyType :: RefEqType :: Nil
+    } else {
+      AnyType :: Nil
+    }
+    cls.info = ClassInfo(cls.owner.thisType, cls, parents, newScope)
     cls.setFlag(NoInits)
 
     // The companion object doesn't really exist, `NoType` is the general
@@ -303,8 +308,17 @@ class Definitions {
   lazy val AnyRefAlias: TypeSymbol = enterAliasType(tpnme.AnyRef, ObjectType)
   def AnyRefType: TypeRef = AnyRefAlias.typeRef
 
-    lazy val Object_eq: TermSymbol = enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
-    lazy val Object_ne: TermSymbol = enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
+    // TODO(abeln): modify usage sites to use `RefEq_eq/ne` once we migrate to explicit nulls?
+    lazy val Object_eq: TermSymbol = if (ctx.settings.YexplicitNulls.value) {
+      RefEq_eq
+    } else {
+      enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
+    }
+    lazy val Object_ne: TermSymbol = if (ctx.settings.YexplicitNulls.value) {
+      RefEq_ne
+    } else {
+      enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
+    }
     lazy val Object_synchronized: TermSymbol = enterPolyMethod(ObjectClass, nme.synchronized_, 1,
         pt => MethodType(List(pt.paramRefs(0)), pt.paramRefs(0)), Final)
     lazy val Object_clone: TermSymbol = enterMethod(ObjectClass, nme.clone_, MethodType(Nil, ObjectType), Protected)
@@ -351,11 +365,40 @@ class Definitions {
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
   def NothingType: TypeRef = NothingClass.typeRef
   lazy val RuntimeNothingModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.Nothing")
+
+  /** `RefEq` is the trait defining the reference equality operators (`eq`, `neq`).
+   *  It's a supertype of both `AnyRef` (which is non-nullable) and `Null`.
+   *  With `RefEq`, we can compare `null` for reference equality a la `null eq foo`.
+   *  `RefEq` is just a marker trait and there's no corresponding class file, since it gets erased to `Object`.
+   */
+  lazy val RefEqClass: ClassSymbol = {
+    assert(ctx.settings.YexplicitNulls.value)
+    enterCompleteClassSymbol(ScalaPackageClass, tpnme.RefEq, Trait, AnyClass.typeRef :: Nil)
+  }
+  def RefEqType: TypeRef = {
+    assert(ctx.settings.YexplicitNulls.value)
+    RefEqClass.typeRef
+  }
+
+    lazy val RefEq_eq: TermSymbol = {
+      assert(ctx.settings.YexplicitNulls.value)
+      enterMethod(RefEqClass, nme.eq, MethodType(List(RefEqType), BooleanType), Final)
+    }
+    lazy val RefEq_ne: TermSymbol = {
+      assert(ctx.settings.YexplicitNulls.value)
+      enterMethod(RefEqClass, nme.ne, MethodType(List(RefEqType), BooleanType), Final)
+    }
+
+    def RefEqMethods: List[TermSymbol] = {
+      assert(ctx.settings.YexplicitNulls.value)
+      List(RefEq_eq, RefEq_ne)
+    }
+
   lazy val NullClass: ClassSymbol = {
     val parents = if (ctx.settings.YexplicitNulls.value) {
-      List(AnyClass.typeRef)
+      List(AnyType, RefEqType)
     } else {
-      List(ObjectClass.typeRef)
+      List(ObjectType)
     }
     enterCompleteClassSymbol(ScalaPackageClass, tpnme.Null, AbstractFinal, parents)
   }
@@ -1205,7 +1248,14 @@ class Definitions {
   lazy val UnqualifiedOwnerTypes: Set[NamedType] =
     RootImportTypes.toSet[NamedType] ++ RootImportTypes.map(_.symbol.moduleClass.typeRef)
 
-  lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
+  lazy val NotRuntimeClasses: Set[Symbol] = {
+    val classes: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
+    if (ctx.settings.YexplicitNulls.value) {
+      classes + RefEqClass
+    } else {
+      classes
+    }
+  }
 
   /** Classes that are known not to have an initializer irrespective of
    *  whether NoInits is set. Note: FunctionXXLClass is in this set
@@ -1400,13 +1450,20 @@ class Definitions {
   def isValueSubClass(sym1: Symbol, sym2: Symbol): Boolean =
     valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
 
-  lazy val specialErasure: SimpleIdentityMap[Symbol, ClassSymbol] =
-    SimpleIdentityMap.Empty[Symbol]
-      .updated(AnyClass, ObjectClass)
-      .updated(AnyValClass, ObjectClass)
-      .updated(SingletonClass, ObjectClass)
-      .updated(TupleClass, ObjectClass)
-      .updated(NonEmptyTupleClass, ProductClass)
+  lazy val specialErasure: SimpleIdentityMap[Symbol, ClassSymbol] = {
+    val idMap =
+      SimpleIdentityMap.Empty[Symbol]
+        .updated(AnyClass, ObjectClass)
+        .updated(AnyValClass, ObjectClass)
+        .updated(SingletonClass, ObjectClass)
+        .updated(TupleClass, ObjectClass)
+        .updated(NonEmptyTupleClass, ProductClass)
+    if (ctx.settings.YexplicitNulls.value) {
+      idMap.updated(RefEqClass, ObjectClass)
+    } else {
+      idMap
+    }
+  }
 
   // ----- Initialization ---------------------------------------------------
 
@@ -1426,7 +1483,7 @@ class Definitions {
       SingletonClass,
       EqualsPatternClass)
 
-    if (ctx.settings.YexplicitNulls.value) synth :+ JavaNullAlias
+    if (ctx.settings.YexplicitNulls.value) synth ++ List(JavaNullAlias, RefEqClass)
     else synth
   }
 
@@ -1435,8 +1492,14 @@ class Definitions {
     OpsPackageClass)
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
-  lazy val syntheticCoreMethods: List[TermSymbol] =
-    AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
+  lazy val syntheticCoreMethods: List[TermSymbol] = {
+    val methods = AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
+    if (ctx.settings.YexplicitNulls.value) {
+      methods ++ RefEqMethods
+    } else {
+      methods
+    }
+  }
 
   lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 

compiler/src/dotty/tools/dotc/core/JavaNullInterop.scala

@@ -146,8 +146,8 @@ object JavaNullInterop {
       !alreadyNullable && (tp match {
         case tp: TypeRef =>
           // We don't modify value types because they're non-nullable even in Java.
-          // We don't modify `Any` because it's already nullable.
-          !tp.symbol.isValueClass && !tp.isRef(defn.AnyClass)
+          // We don't modify `Any` or `RefEq` because they're already nullable.
+          !tp.symbol.isValueClass && !tp.isRef(defn.AnyClass) && !tp.isRef(defn.RefEqClass)
         case _ => true
       })
     }

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -160,6 +160,7 @@ object StdNames {
       scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit)
 
     // some types whose companions we utilize
+    final val RefEq: N      = "RefEq"
     final val AnyRef: N     = "AnyRef"
     final val Array: N      = "Array"
     final val List: N       = "List"

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -563,6 +563,13 @@ object Types {
         val rsym = r.classSymbol
         if (lsym isSubClass rsym) rsym
         else if (rsym isSubClass lsym) lsym
+        else if (ctx.settings.YexplicitNulls.value && this.isNullableUnion) {
+          val OrType(left, _) = this.normNullableUnion
+          // If `left` is a reference type, then the class LUB of `left | Null` is `RefEq`.
+          // This is another one-of case that keeps this method sound, but not complete.
+          if (left.classSymbol isSubClass defn.ObjectClass) defn.RefEqClass
+          else NoSymbol
+        }
         else NoSymbol
       case _ =>
         NoSymbol

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -54,8 +54,14 @@ class Erasure extends Phase with DenotTransformer {
         // After erasure, all former Any members are now Object members
         val ClassInfo(pre, _, ps, decls, selfInfo) = ref.info
         val extendedScope = decls.cloneScope
-        for (decl <- defn.AnyClass.classInfo.decls)
-          if (!decl.isConstructor) extendedScope.enter(decl)
+        def addDecls(cls: ClassSymbol) = {
+          for (decl <- cls.classInfo.decls)
+            if (!decl.isConstructor) extendedScope.enter(decl)
+        }
+        addDecls(defn.AnyClass)
+        if (ctx.settings.YexplicitNulls.value) {
+          addDecls(defn.RefEqClass)
+        }
         ref.copySymDenotation(
           info = transformInfo(ref.symbol,
               ClassInfo(pre, defn.ObjectClass, ps, extendedScope, selfInfo))
@@ -68,7 +74,14 @@ class Erasure extends Phase with DenotTransformer {
             defn.ObjectClass.primaryConstructor
         else oldSymbol
         val oldOwner = ref.owner
-        val newOwner = if (oldOwner eq defn.AnyClass) defn.ObjectClass else oldOwner
+        val newOwner = {
+          val shouldBeObject = if (ctx.settings.YexplicitNulls.value) {
+            (oldOwner eq defn.AnyClass) || (oldOwner eq defn.RefEqClass)
+          } else {
+            oldOwner eq defn.AnyClass
+          }
+          if (shouldBeObject) defn.ObjectClass else oldOwner
+        }
         val oldInfo = ref.info
         val newInfo = transformInfo(oldSymbol, oldInfo)
         val oldFlags = ref.flags

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

@@ -0,0 +1,17 @@
+
+// Test that the synthetic trait `RefEq` is usable.
+
+class Test {
+  val x: RefEq = null
+  val y: RefEq = "hello"
+
+  x.eq(y)
+  y.eq(x)
+  x.eq(x)
+  y.eq(y)
+
+  x.ne(y)
+  y.ne(x)
+  x.ne(x)
+  y.ne(y)
+}

tests/explicit-nulls/run/subtype-any.scala

@@ -0,0 +1,28 @@
+
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    assert(null.eq(null))
+    assert(!null.ne(null))
+
+    assert(!null.eq("hello"))
+    assert(null.ne("hello"))
+
+    assert(!null.eq(4))
+    assert(null.ne(4))
+
+    assert(!"hello".eq(null))
+    assert("hello".ne(null))
+
+    assert(!4.eq(null))
+    assert(4.ne(null))
+
+    val x: String|Null = null
+    assert(x.eq(null))
+    assert(!x.ne(null))
+
+    val x2: AnyRef|Null = "world"
+    assert(!x2.eq(null))
+    assert(x2.ne(null))
+  }
+}