Definitions enabling multiversal equals

These follow he strawman design. One addition
`Null' also needs overloaded variants to work
correctly in all comparisons.

Author: odersky

src/dotty/Eq.scala

@@ -0,0 +1,25 @@
+package dotty
+import scala.annotation.implicitNotFound
+
+/** A marker class indicating that values of kind `T` can be compared. */
+class Eq[-T]
+
+/** Besides being a companion object, this object
+ *  can also be used as a value that's compatible with
+ *  any instance of `Eq`.
+ */
+object Eq extends Eq[Any] {
+
+  /** A type that always causes an "implicit not found".
+   *  Used to mark some overloaded variants of `==` as errors.
+   */
+  @implicitNotFound("cannot compare value of type ${T} with a value outside its equality class")
+  trait Impossible[T]
+
+  /** An implicit that provides an `Eq` instance for all types `T`
+   *  such that `T <: EqClass[T]`.
+   */
+  implicit def eqEq[T <: EqClass[T]]: Eq[T] = Eq
+
+}
+

src/dotty/EqClass.scala

@@ -0,0 +1,21 @@
+package dotty
+import scala.annotation.implicitNotFound
+
+/** A class providing a specialized notion of equality, allowing
+ *  only values in the same equality class to be compared.
+ */
+trait EqClass[-T] {
+
+  /** Comparison operation between values in the same equality class */
+  final def == [T >: this.type <: EqClass[_]](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other)
+
+  /** A "dead-end" overload which will lead to an implicit not found error
+   *  when comparing a value in an equality class with a value tha's outside
+   *  all equality classes.
+   */
+  final def == [T](other: T)(implicit ce: Eq.Impossible[T]): Boolean = ???
+
+  /** A special overload for comparisons with `null` */
+  final def == (other: Null): Boolean = this.equals(other)
+}
+

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

@@ -86,9 +86,12 @@ class Definitions {
   }
 
   private def newPolyMethod(cls: ClassSymbol, name: TermName, typeParamCount: Int,
-                    resultTypeFn: PolyType => Type, flags: FlagSet = EmptyFlags) = {
+                    resultTypeFn: PolyType => Type, flags: FlagSet = EmptyFlags,
+                    typeBounds: List[TypeBounds] = Nil) = {
     val tparamNames = tpnme.syntheticTypeParamNames(typeParamCount)
-    val tparamBounds = tparamNames map (_ => TypeBounds.empty)
+    val tparamBounds =
+      if (typeBounds.nonEmpty) typeBounds
+      else tparamNames map (_ => TypeBounds.empty)
     val ptype = PolyType(tparamNames)(_ => tparamBounds, resultTypeFn)
     newMethod(cls, name, ptype, flags)
   }
@@ -171,8 +174,27 @@ class Definitions {
     lazy val Any_isInstanceOf = newT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
     lazy val Any_asInstanceOf = newT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, PolyParam(_, 0), Final)
 
+    /** A method with signature
+     *
+     *     def == [T <: EqClass[_]]($x0: T)(implicit $x1: Eq.Impossible[T]): Boolean = ???
+     */
+    lazy val Any_forbidden_== = newMethod(AnyClass, nme.EQ, new ForbiddenEqCompleter, Final)
+
+    class ForbiddenEqCompleter extends LazyType {
+      override def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+        denot.info =
+          PolyType(tpnme.syntheticTypeParamNames(1))(
+            pt => List(TypeBounds.upper(EqClassType.appliedTo(TypeBounds.empty))),
+            pt => MethodType(List(PolyParam(pt, 0)),
+                   ImplicitMethodType(List(EqImpossibleType.appliedTo(PolyParam(pt, 0))),
+                     BooleanType)))
+      }
+    }
+
+    lazy val Any_null_== = newMethod(AnyClass, nme.EQ, MethodType(List(NullType), BooleanType), Final)
+
     def AnyMethods = List(Any_==, Any_!=, Any_equals, Any_hashCode,
-      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf)
+      Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_forbidden_==, Any_null_==)
 
   lazy val ObjectClass: ClassSymbol = {
     val cls = ctx.requiredClass("java.lang.Object")
@@ -212,8 +234,13 @@ class Definitions {
   lazy val NothingClass: ClassSymbol = newCompleteClassSymbol(
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
   def NothingType = NothingClass.typeRef
-  lazy val NullClass: ClassSymbol = newCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef))
+  lazy val NullClass: ClassSymbol = {
+    val nc = newCompleteClassSymbol(
+      ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef))
+    val Null_Equals_== = newMethod(nc, nme.EQ, MethodType(List(EqClassType), BooleanType)).entered
+    val Null_Null_== = newMethod(nc, nme.EQ, MethodType(List(nc.typeRef), BooleanType)).entered
+    nc
+  }
   def NullType = NullClass.typeRef
 
   lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef")
@@ -282,7 +309,6 @@ class Definitions {
   lazy val ArrayModuleType = ctx.requiredModuleRef("scala.Array")
   def ArrayModule(implicit ctx: Context) = ArrayModuleType.symbol.moduleClass.asClass
 
-
   lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc)
   def UnitClass(implicit ctx: Context) = UnitType.symbol.asClass
   lazy val BooleanType = valueTypeRef("scala.Boolean", BoxedBooleanType, java.lang.Boolean.TYPE, BooleanEnc)
@@ -401,6 +427,12 @@ class Definitions {
     lazy val StringAdd_plusR = StringAddClass.requiredMethodRef(nme.raw.PLUS)
     def StringAdd_+(implicit ctx: Context) = StringAdd_plusR.symbol
 
+  lazy val EqType: TypeRef                      = ctx.requiredClassRef("dotty.Eq")
+  def EqClass(implicit ctx: Context)            = EqType.symbol.asClass
+  lazy val EqClassType: TypeRef                 = ctx.requiredClassRef("dotty.EqClass")
+  def EqClassClass(implicit ctx: Context)       = EqClassType.symbol.asClass
+  lazy val EqImpossibleType: TypeRef            = ctx.requiredClassRef("dotty.Eq.Impossible")
+  def EqImpossibleClass(implicit ctx: Context)  = EqImpossibleType.symbol.asClass
   lazy val PairType: TypeRef                    = ctx.requiredClassRef("dotty.Pair")
   def PairClass(implicit ctx: Context) = PairType.symbol.asClass
   lazy val PartialFunctionType: TypeRef         = ctx.requiredClassRef("scala.PartialFunction")