Merge pull request #1231 from dotty-staging/fix-equality

Fixes related to equality strawman

Author: odersky

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

@@ -449,6 +449,8 @@ class Definitions {
   def ContravariantBetweenAnnot(implicit ctx: Context) = ContravariantBetweenAnnotType.symbol.asClass
   lazy val DeprecatedAnnotType = ctx.requiredClassRef("scala.deprecated")
   def DeprecatedAnnot(implicit ctx: Context) = DeprecatedAnnotType.symbol.asClass
+  lazy val ImplicitNotFoundAnnotType = ctx.requiredClassRef("scala.annotation.implicitNotFound")
+  def ImplicitNotFoundAnnot(implicit ctx: Context) = ImplicitNotFoundAnnotType.symbol.asClass
   lazy val InvariantBetweenAnnotType = ctx.requiredClassRef("dotty.annotation.internal.InvariantBetween")
   def InvariantBetweenAnnot(implicit ctx: Context) = InvariantBetweenAnnotType.symbol.asClass
   lazy val MigrationAnnotType = ctx.requiredClassRef("scala.annotation.migration")

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

@@ -678,7 +678,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     isSubType(tp11, tp21) && {
       val leftConstraint = constraint
       constraint = preConstraint
-      if (isSubType(tp12, tp22) && !subsumes(leftConstraint, constraint, preConstraint))
+      if (!(isSubType(tp12, tp22) && subsumes(leftConstraint, constraint, preConstraint)))
         constraint = leftConstraint
       true
     } || isSubType(tp12, tp22)

src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -1611,7 +1611,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
           // (otherwise equality is required)
           def compareOp: (Tree, Tree) => Tree =
             if (aligner.isStar) _.select(defn.Int_>=).appliedTo(_)
-            else         _.select(defn.Int_==).appliedTo(_)
+            else _.select(defn.Int_==).appliedTo(_)
 
           // `if (binder != null && $checkExpectedLength [== | >=] 0) then else zero`
           (seqTree(binder).select(defn.Any_!=).appliedTo(Literal(Constant(null)))).select(defn.Boolean_&&).appliedTo(compareOp(checkExpectedLength, Literal(Constant(0))))

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

@@ -116,6 +116,18 @@ object ErrorReporting {
            | found   : $found
            | required: $expected""".stripMargin + whyNoMatchStr(found, expected)
     }
+
+    /** Format `raw` implicitNotFound argument, replacing all
+     *  occurrences of `${X}` where `X` is in `paramNames` with the
+     *  corresponding shown type in `args`.
+     */
+    def implicitNotFoundString(raw: String, paramNames: List[String], args: List[Type]): String = {
+      def translate(name: String): Option[String] = {
+        val idx = paramNames.indexOf(name)
+        if (idx >= 0) Some(args(idx).show) else None
+      }
+      """\$\{\w*\}""".r.replaceSomeIn(raw, m => translate(m.matched.drop(2).init))
+    }
   }
 
   def err(implicit ctx: Context): Errors = new Errors

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

@@ -46,7 +46,7 @@ object Inferencing {
 
   /** Instantiate selected type variables `tvars` in type `tp` */
   def instantiateSelected(tp: Type, tvars: List[Type])(implicit ctx: Context): Unit =
-    new IsFullyDefinedAccumulator(new ForceDegree.Value(tvars.contains)).process(tp)
+    new IsFullyDefinedAccumulator(new ForceDegree.Value(tvars.contains, minimizeAll = true)).process(tp)
 
   /** The accumulator which forces type variables using the policy encoded in `force`
    *  and returns whether the type is fully defined. The direction in which
@@ -86,6 +86,7 @@ object Inferencing {
           }
           else {
             val minimize =
+              force.minimizeAll ||
               variance >= 0 && !(
                 force == ForceDegree.noBottom &&
                 defn.isBottomType(ctx.typeComparer.approximation(tvar.origin, fromBelow = true)))
@@ -293,9 +294,9 @@ object Inferencing {
 
 /** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */
 @sharable object ForceDegree {
-  class Value(val appliesTo: TypeVar => Boolean)
-  val none = new Value(_ => false)
-  val all = new Value(_ => true)
-  val noBottom = new Value(_ => true)
+  class Value(val appliesTo: TypeVar => Boolean, val minimizeAll: Boolean)
+  val none = new Value(_ => false, minimizeAll = false)
+  val all = new Value(_ => true, minimizeAll = false)
+  val noBottom = new Value(_ => true, minimizeAll = false)
 }
 

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

@@ -1529,7 +1529,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           }
           def issueErrors() = {
             for (err <- errors) ctx.error(err(), tree.pos.endPos)
-            tree
+            tree.withType(wtp.resultType)
           }
           val args = (wtp.paramNames, wtp.paramTypes).zipped map { (pname, formal) =>
             def where = d"parameter $pname of $methodStr"
@@ -1541,7 +1541,16 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
               case failure: SearchFailure =>
                 val arg = synthesizedClassTag(formal)
                 if (!arg.isEmpty) arg
-                else implicitArgError(d"no implicit argument of type $formal found for $where" + failure.postscript)
+                else {
+                  var msg = d"no implicit argument of type $formal found for $where" + failure.postscript
+                  for (notFound <- formal.typeSymbol.getAnnotation(defn.ImplicitNotFoundAnnot);
+                       Literal(Constant(raw: String)) <- notFound.argument(0))
+                    msg = err.implicitNotFoundString(
+                        raw,
+                        formal.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
+                        formal.argInfos)
+                  implicitArgError(msg)
+                }
             }
           }
           if (errors.nonEmpty) {

tests/neg/EqualityStrawman1.scala

@@ -0,0 +1,79 @@
+package strawman.equality
+import annotation.implicitNotFound
+
+object EqualityStrawman1 {
+
+  trait Eq[-T]
+
+  @implicitNotFound("cannot compare value of type ${T} with a value outside its equality class")
+  trait Impossible[T]
+
+  object Eq extends Eq[Any]
+
+  trait Base {
+    def === (other: Any): Boolean = this.equals(other)
+    def === [T <: CondEquals](other: T)(implicit ce: Impossible[T]): Boolean = ???
+  }
+
+  trait CondEquals extends Base {
+    def === [T >: this.type <: CondEquals](other: T)(implicit ce: Eq[T]): Boolean = this.equals(other)
+    def === [T](other: T)(implicit ce: Impossible[T]): Boolean = ???
+  }
+
+  trait Equals[-T] extends CondEquals
+
+  case class Str(str: String) extends CondEquals
+
+  case class Num(x: Int) extends Equals[Num]
+
+  case class Other(x: Int) extends Base
+
+  trait Option[+T] extends CondEquals
+  case class Some[+T](x: T) extends Option[T]
+  case object None extends Option[Nothing]
+
+  implicit def eqStr: Eq[Str] = Eq
+  //implicit def eqNum: Eq[Num] = Eq
+  implicit def eqOption[T: Eq]: Eq[Option[T]] = Eq
+
+  implicit def eqEq[T <: Equals[T]]: Eq[T] = Eq
+
+  def main(args: Array[String]): Unit = {
+    val x = Str("abc")
+    x === x
+
+    val n = Num(2)
+    val m = Num(3)
+    n === m
+
+    Other(1) === Other(2)
+
+    Some(x) === None
+    Some(x) === Some(Str(""))
+    val z: Option[Str] = Some(Str("abc"))
+    z === Some(x)
+    z === None
+    Some(x) === z
+    None === z
+
+
+    def ddistinct[T <: Base: Eq](xs: List[T]): List[T] = xs match {
+      case Nil => Nil
+      case x :: xs => x :: xs.filterNot(x === _)
+    }
+
+    ddistinct(List(z, z, z))
+
+    x === n  // error
+    n === x  // error
+    x === Other(1)  // error
+    Other(2) === x // error
+    z === Some(n) // error
+    z === n // error
+    Some(n) === z // error
+    n === z // error
+    Other(1) === z // error
+    z === Other(1) // error
+    ddistinct(List(z, n)) // error
+  }
+}

tests/neg/subtyping.scala

@@ -6,7 +6,7 @@ class A extends B
 object Test {
   def test1(): Unit = {
     implicitly[B#X <:< A#X] // error: no implicit argument
-  } // error: no implicit argument
+  }
   def test2(): Unit = {
     val a : { type T; type U } = ??? // error // error
     implicitly[a.T <:< a.U] // error: no implicit argument

tests/pos/i878.scala

@@ -0,0 +1,17 @@
+class X
+
+class Message[-A]
+class Seg[+A]
+class IChan[A] {
+  def add[B >: A](x: Seg[B])(implicit ev: Message[B]): IChan[B] = ???
+}
+
+class Test {
+  def test: Unit = {
+    implicit val mx: Message[X] = ???
+    val fx: IChan[X] = ???
+    val sx: Seg[X] = ???
+    // the implicit `mx` should be used even though the type parameter of Message is contravariant
+    fx.add(sx)
+  }
+}