Add Eq instances of standard types to Predef

To make tests pass, this required a looser specification of
`assumedCanEquals`, so that an abstract type T can be compared to
arbitrary values, as long as its upper bound can be compared. E.g.

    T == null
    T == "abc"

Author: odersky

src/dotty/DottyPredef.scala

@@ -3,11 +3,35 @@ package dotty
 import scala.reflect.runtime.universe.TypeTag
 import scala.reflect.ClassTag
 import scala.Predef.???
+import scala.collection.Seq
 
 /** unimplemented implicit for TypeTag */
 object DottyPredef {
   implicit def typeTag[T]: TypeTag[T] = ???
 
   implicit def arrayTag[T](implicit ctag: ClassTag[T]): ClassTag[Array[T]] =
     ctag.wrap
+
+  implicit def eqNumber   : Eq[Number, Number] = Eq
+  implicit def eqString   : Eq[String, String] = Eq
+
+  // true asymmetry, modeling the (somewhat problematic) nature of equals on Proxies
+  implicit def eqProxy    : Eq[Proxy, Any]     = Eq
+
+  implicit def eqSeq[T, U](implicit eq: Eq[T, U]): Eq[Seq[T], Seq[U]] = Eq
+
+  implicit def eqByteNum  : Eq[Byte, Number]   = Eq
+  implicit def eqNumByte  : Eq[Number, Byte]   = Eq
+  implicit def eqCharNum  : Eq[Char, Number]   = Eq
+  implicit def eqNumChar  : Eq[Number, Char]   = Eq
+  implicit def eqShortNum : Eq[Short, Number]  = Eq
+  implicit def eqNumShort : Eq[Number, Short]  = Eq
+  implicit def eqIntNum   : Eq[Int, Number]    = Eq
+  implicit def eqNumInt   : Eq[Number, Int]    = Eq
+  implicit def eqLongNum  : Eq[Long, Number]   = Eq
+  implicit def eqNumLong  : Eq[Number, Long]   = Eq
+  implicit def eqFloatNum : Eq[Float, Number]  = Eq
+  implicit def eqNumFloat : Eq[Number, Float]  = Eq
+  implicit def eqDoubleNum: Eq[Double, Number] = Eq
+  implicit def eqNumDouble: Eq[Number, Double] = Eq
 }

src/dotty/tools/dotc/typer/Implicits.scala

@@ -472,8 +472,20 @@ trait Implicits { self: Typer =>
     EmptyTree
   }
 
-  private def assumedCanEqual(ltp: Type, rtp: Type)(implicit ctx: Context) =
-    ltp.isError || rtp.isError || ltp <:< rtp || rtp <:< ltp
+  private def assumedCanEqual(ltp: Type, rtp: Type)(implicit ctx: Context) = {
+    val lift = new TypeMap {
+      def apply(t: Type) = t match {
+        case t: TypeRef =>
+          t.info match {
+            case TypeBounds(lo, hi) if lo ne hi => hi
+            case _ => t
+          }
+        case _ =>
+          if (variance > 0) mapOver(t) else t
+      }
+    }
+    ltp.isError || rtp.isError || ltp <:< lift(rtp) || rtp <:< lift(ltp)
+  }
 
   /** Check that equality tests between types `ltp` and `rtp` make sense */
   def checkCanEqual(ltp: Type, rtp: Type, pos: Position)(implicit ctx: Context): Unit =

test/test/CompilerTest.scala

@@ -238,9 +238,13 @@ abstract class CompilerTest {
 
     val nerrors = reporter.errorCount
     val xerrors = (expectedErrorsPerFile map {_.totalErrors}).sum
+    def expectedErrorFiles =
+      expectedErrorsPerFile.collect{
+        case er if er.totalErrors > 0 => er.fileName
+      }
     assert(nerrors == xerrors,
       s"""Wrong # of errors. Expected: $xerrors, found: $nerrors
-         |Files with expected errors: ${expectedErrorsPerFile.collect{ case er if er.totalErrors > 0 => er.fileName} }
+         |Files with expected errors: $expectedErrorFiles%, %
        """.stripMargin)
     // NEG TEST
     if (xerrors > 0) {

tests/neg/equality.scala

@@ -14,12 +14,17 @@ object equality {
   implicit def eqNum: Eq[Num, Num] = Eq
   implicit def eqOption[T, U](implicit e: Eq[T, U]): Eq[Option[T], Option[U]] = Eq
 
+  case class PString(a: String) extends Proxy {
+    def self = a
+  }
+
+/*
   implicit def eqString: Eq[String, String] = Eq
   implicit def eqInt: Eq[Int, Int] = Eq
   implicit def eqNumber: Eq[Number, Number] = Eq
   implicit def eqIntNumber: Eq[Int, Number] = Eq
   implicit def eqNumberInt: Eq[Number, Int] = Eq
-
+*/
   def main(args: Array[String]): Unit = {
     Some(Other(3)) == None
 
@@ -73,6 +78,9 @@ object equality {
     i == bi
     bi == i
 
+    val ps = PString("hello")
+    ps == "world"
+
     n match {
       case None =>   // error
     }
@@ -96,5 +104,6 @@ object equality {
     1 == "abc" // error
     "abc" == bi // error
     bi == "abc" // error
+    "world" == ps // error
   }
 }