Downwards comparisons for implicit search and overloading resolution

This is a backport of the following Dotty change to scalac,

scala/scala3@8954026

As in the Dotty implementation the specificity comparison which is used
for overload resolution and implicit selection is now performed as-if
all contravariant positions in top level type constructors were
covariant.

Currently this breaks test/files/run/t2030.scala in exactly the same way
as in Dotty as reported here,

scala/scala3#1246 (comment)

and in this PR it has been changed to a neg test. However,
test/files/run/t2030.scala passes when this PR is combined with,

scala#6139

so if/when that is merged it can be switched back to a pos test.

Fixes scala/bug#2509. Fixes scala/bug#7768.

Author: milessabin

src/compiler/scala/tools/nsc/typechecker/Infer.scala

@@ -837,13 +837,33 @@ trait Infer extends Checkable {
         case _                                                              => onRight
       }
     }
+
     private def isAsSpecificValueType(tpe1: Type, tpe2: Type, undef1: List[Symbol], undef2: List[Symbol]): Boolean = tpe1 match {
       case PolyType(tparams1, rtpe1) =>
         isAsSpecificValueType(rtpe1, tpe2, undef1 ::: tparams1, undef2)
       case _                         =>
         tpe2 match {
           case PolyType(tparams2, rtpe2) => isAsSpecificValueType(tpe1, rtpe2, undef1, undef2 ::: tparams2)
-          case _                         => existentialAbstraction(undef1, tpe1) <:< existentialAbstraction(undef2, tpe2)
+          case _                         =>
+
+            val e1 = existentialAbstraction(undef1, tpe1)
+            val e2 = existentialAbstraction(undef2, tpe2)
+
+            // Backport of fix for https://github.com/scala/bug/issues/2509
+            // from Dotty https://github.com/lampepfl/dotty/commit/89540268e6c49fb92b9ca61249e46bb59981bf5a
+            val flip = new TypeMap(trackVariance = true) {
+              def apply(tp: Type): Type = tp match {
+                case TypeRef(pre, sym, args) if variance > 0 && sym.typeParams.exists(_.isContravariant) =>
+                  TypeRef(pre, sym.flipped, args)
+                case _: TypeRef => tp
+                case _ =>
+                  mapOver(tp)
+              }
+            }
+
+            val bt = e1.baseType(e2.typeSymbol)
+            val lhs = if(bt != NoType) bt else e1
+            flip(lhs) <:< flip(e2)
         }
     }
 

src/library/scala/collection/immutable/TreeSet.scala

@@ -24,6 +24,7 @@ object TreeSet extends ImmutableSortedSetFactory[TreeSet] {
   implicit def implicitBuilder[A](implicit ordering: Ordering[A]): Builder[A, TreeSet[A]] = newBuilder[A](ordering)
   override def newBuilder[A](implicit ordering: Ordering[A]): Builder[A, TreeSet[A]] =
     new SetBuilder(empty[A](ordering))
+  override implicit def newCanBuildFrom[A](implicit ord : Ordering[A]) : CanBuildFrom[Coll, A, TreeSet[A]] = super.newCanBuildFrom
 
   /** The empty set of this type
    */

src/reflect/scala/reflect/internal/Symbols.scala

@@ -2005,6 +2005,8 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     /** Internal method to clone a symbol's implementation with the given flags and no info. */
     def cloneSymbolImpl(owner: Symbol, newFlags: Long): TypeOfClonedSymbol
 
+    def flipped: Symbol = this
+
 // ------ access to related symbols --------------------------------------------------
 
     /** The next enclosing class. */
@@ -3375,6 +3377,14 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
       clone
     }
 
+    override lazy val flipped: ClassSymbol = {
+      val clone = cloneSymbol(owner)
+      clone.rawInfo.typeParams.foreach { sym =>
+        if (sym.isContravariant) sym.resetFlag(Flag.CONTRAVARIANT).setFlag(Flag.COVARIANT)
+      }
+      clone
+    }
+
     override def derivedValueClassUnbox =
       // (info.decl(nme.unbox)) orElse      uncomment once we accept unbox methods
       (info.decls.find(_ hasAllFlags PARAMACCESSOR | METHOD) getOrElse

test/files/neg/t2509-2.check

@@ -0,0 +1,7 @@
+t2509-2.scala:26: error: ambiguous implicit values:
+ both value xb in object Test of type => X[B,Int]
+ and value xa in object Test of type => X[A,Boolean]
+ match expected type X[B,U]
+  val fb = f(new B)
+            ^
+one error found

test/files/neg/t2509-2.scala

@@ -0,0 +1,28 @@
+class A
+class B extends A
+class C extends B
+
+trait X[-T, U] {
+  val u: U
+}
+
+object XA extends X[A, Boolean] {
+  val u = true
+}
+
+object XB extends X[B, Int] {
+  val u = 23
+}
+
+object Test {
+  implicit def f[T, U](t: T)(implicit x: X[T, U]): U = x.u
+  implicit val xa: X[A, Boolean] = XA
+  implicit val xb: X[B, Int] = XB
+
+  val fa = f(new A)
+  val ffa: Boolean = fa
+
+  // Should be ambiguous
+  val fb = f(new B)
+  val ffb: Int = fb
+}

test/files/neg/t2509-3.check

@@ -0,0 +1,4 @@
+t2509-3.scala:31: error: value value is not a member of B
+    println("B: " + b.value)
+                      ^
+one error found

test/files/neg/t2509-3.scala

@@ -0,0 +1,34 @@
+class A
+class B extends A
+
+trait Y {
+  def value: String
+} 
+
+trait X[-T] {
+  def y(t: T): Y
+}
+
+trait Z[-T] extends X[T]
+
+object ZA extends Z[A] {
+  def y(a: A) = new Y { def value = a.getClass + ": AValue" }
+}
+
+object XB extends X[B] {
+  def y(b: B) = new Y { def value = b.getClass + ": BValue" }
+}
+
+object Test {
+  implicit def f[T](t: T)(implicit x: X[T]): Y = x.y(t)
+  implicit val za: Z[A] = ZA
+  implicit val xb: X[B] = XB
+
+  def main(argv: Array[String]): Unit = {
+    val a = new A
+    val b = new B
+    println("A: " + a.value)
+    println("B: " + b.value)
+  }
+}
+

test/files/neg/t2509-4.check

@@ -0,0 +1,4 @@
+t2509-4.scala:31: error: value value is not a member of B
+    println("B: " + b.value)
+                      ^
+one error found

test/files/neg/t2509-7b.check

@@ -0,0 +1,7 @@
+t2509-7b.scala:30: error: ambiguous implicit values:
+ both method make in object X of type => Both[X,X]
+ and method make in trait Factory of type => Both[Y,Y]
+ match expected type Both[Y,X]
+  get
+  ^
+one error found

test/files/neg/t2509-7b.scala

@@ -0,0 +1,31 @@
+class Both[-A, +B]
+
+trait Factory[A] {
+  implicit def make: Both[A, A] = new Both[A, A]
+}
+
+trait X
+object X extends Factory[X] {
+  override implicit def make: Both[X, X] = super.make
+}
+
+class Y extends X
+object Y extends Factory[Y] {
+  // See test/files/pos/t2509-7a.scala ... discussion below
+  // override implicit def make: Both[Y, Y] = super.make
+}
+
+object Test {
+  def get(implicit ev: Both[Y, X]) = ev
+
+  // There are two possible implicits here: X.make and Y.make, neither are
+  // subtype of each other, so who wins?
+  // - Under the old scheme it's X.make because `isAsGood` sees that X.make is defined
+  // in X whereas Y.make is defined in Factory
+  // - Under the new scheme it's ambiguous because we replace contravariance by covariance
+  // in top-level type parameters so Y.make is treated as a subtype of X.make
+  // In both schemes we can get Y.make to win by uncommenting the override for make in Y
+  // (Y wins against X because `isDerived` also considers the subtyping relationships
+  // of companion classes)
+  get
+}

test/files/run/t2030.scala renamed to test/files/pos/t2030.scala

@@ -0,0 +1,13 @@
+// See https://github.com/lampepfl/dotty/issues/2974
+trait Foo[-T]
+
+trait Bar[-T] extends Foo[T]
+
+object Test {
+  implicit val fa: Foo[Any] = ???
+  implicit val ba: Bar[Int] = ???
+
+  def test: Unit = {
+    implicitly[Foo[Int]]
+  }
+}

test/files/pos/t2509-5.scala

@@ -0,0 +1,33 @@
+class A
+class B extends A
+
+trait Y {
+  def value: String
+} 
+
+trait X[-T] {
+  def y(t: T): Y
+}
+
+trait Z[-T] extends X[T]
+
+object XA extends X[A] {
+  def y(a: A) = new Y { def value = a.getClass + ": AValue" }
+}
+
+object ZB extends Z[B] {
+  def y(b: B) = new Y { def value = b.getClass + ": BValue" }
+}
+
+object Test {
+  implicit def f[T](t: T)(implicit x: X[T]): Y = x.y(t)
+  implicit val za: X[A] = XA
+  implicit val xb: Z[B] = ZB
+
+  def main(argv: Array[String]): Unit = {
+    val a = new A
+    val b = new B
+    println("A: " + a.value)
+    println("B: " + b.value)
+  }
+}

test/files/pos/t2509-6.scala

@@ -0,0 +1,31 @@
+class Both[-A, +B]
+
+trait Factory[A] {
+  implicit def make: Both[A, A] = new Both[A, A]
+}
+
+trait X
+object X extends Factory[X] {
+  override implicit def make: Both[X, X] = super.make
+}
+
+class Y extends X
+object Y extends Factory[Y] {
+  // See test/files/neg/t2509-7b.scala ... discussion below
+  override implicit def make: Both[Y, Y] = super.make
+}
+
+object Test {
+  def get(implicit ev: Both[Y, X]) = ev
+
+  // There are two possible implicits here: X.make and Y.make, neither are
+  // subtype of each other, so who wins?
+  // - Under the old scheme it's X.make because `isAsGood` sees that X.make is defined
+  // in X whereas Y.make is defined in Factory
+  // - Under the new scheme it's ambiguous because we replace contravariance by covariance
+  // in top-level type parameters so Y.make is treated as a subtype of X.make
+  // In both schemes we can get Y.make to win by uncommenting the override for make in Y
+  // (Y wins against X because `isDerived` also considers the subtyping relationships
+  // of companion classes)
+  get
+}

test/files/pos/t2509-7a.scala

@@ -0,0 +1,3 @@
+warning: there was one feature warning; re-run with -feature for details
+A: class A: AValue
+B: class B: BValue

test/files/run/t2509-1.check

@@ -0,0 +1,31 @@
+class A
+class B extends A
+
+trait Y {
+  def value: String
+}
+
+trait X[-T] {
+  def y(t: T): Y
+}
+
+object XA extends X[A] {
+  def y(a: A) = new Y { def value = a.getClass + ": AValue" }
+}
+
+object XB extends X[B] {
+  def y(b: B) = new Y { def value = b.getClass + ": BValue" }
+}
+
+object Test {
+  implicit def f[T](t: T)(implicit x: X[T]): Y = x.y(t)
+  implicit val xa: X[A] = XA
+  implicit val xb: X[B] = XB
+
+  def main(argv: Array[String]) {
+    val a = new A
+    val b = new B
+    println("A: " + a.value)
+    println("B: " + b.value)
+  }
+}

test/files/run/t2509-1.scala

@@ -0,0 +1,3 @@
+warning: there was one feature warning; re-run with -feature for details
+A: class A: AValue
+B: class B: BValue

test/files/run/t2509-4.check

@@ -0,0 +1,34 @@
+class A
+class B extends A
+
+trait Y {
+  def value: String
+} 
+
+trait X[-T] {
+  def y(t: T): Y
+}
+
+trait Z[-T] extends X[T]
+
+object XA extends Z[A] {
+  def y(a: A) = new Y { def value = a.getClass + ": AValue" }
+}
+
+object ZB extends Z[B] {
+  def y(b: B) = new Y { def value = b.getClass + ": BValue" }
+}
+
+object Test {
+  implicit def f[T](t: T)(implicit x: X[T]): Y = x.y(t)
+  implicit val za: X[A] = XA
+  implicit val xb: Z[B] = ZB
+
+  def main(argv: Array[String]): Unit = {
+    val a = new A
+    val b = new B
+    println("A: " + a.value)
+    println("B: " + b.value)
+  }
+}
+

test/files/run/t2509-4.scala

@@ -0,0 +1,3 @@
+Inv[A] Inv[B] Inv[C] Inv[D] Inv[E]
+Con[A] Con[A] Con[C] Con[C] Con[E]
+Cov[E] Cov[E] Cov[E] Cov[E] Cov[E]