Rely on variance to typecheck more uses of wildcards

If we can't capture the wildcard argument, we might still be able to
return true to the subtype check by approximating the wildcard based on
variance.

This leads to a regression in t5729 were two overloads are now
considered ambiguous, but the only reason they were not ambiguous before
was that the subtype test failed when it shouldn't, so this seems
acceptable.

Author: smarter

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

@@ -1181,7 +1181,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
          *  If the original left-hand type `leftRoot` is a path `p.type`,
          *  and the current widened left type is an application with wildcard arguments
          *  such as `C[_]`, where `X` is `C`'s type parameter corresponding to the `_` argument,
-         *  compare with `C[p.X]` instead. Otherwise return `false`.
+         *  compare with `C[p.X]` instead. Otherwise approximate based on variance.
          *  Also do a capture conversion in either of the following cases:
          *
          *   - If we are after typer. We generally relax soundness requirements then.
@@ -1203,10 +1203,18 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
          *  paths is less intrusive than skolemization.
          */
         def compareCaptured(arg1: TypeBounds, arg2: Type) = tparam match {
-          case tparam: Symbol
-          if leftRoot.isStable || (ctx.isAfterTyper || ctx.mode.is(Mode.TypevarsMissContext)) && leftRoot.member(tparam.name).exists =>
-            val captured = TypeRef(leftRoot, tparam)
-            isSubArg(captured, arg2)
+          case tparam: Symbol =>
+            if (leftRoot.isStable || (ctx.isAfterTyper || ctx.mode.is(Mode.TypevarsMissContext))
+                && leftRoot.member(tparam.name).exists) {
+              val captured = TypeRef(leftRoot, tparam)
+              isSubArg(captured, arg2)
+            }
+            else if (v > 0)
+              isSubType(paramBounds(tparam).hi, arg2)
+            else if (v < 0)
+              isSubType(arg2, paramBounds(tparam).lo)
+            else
+              false
           case _ =>
             false
         }

tests/neg/t5729.scala

@@ -0,0 +1,7 @@
+object C {
+  def join(in: Seq[List[_]]): Int = 1
+  def join[S](in: Seq[List[S]]): String = "x"
+
+  val x= join(Seq[List[Int]]()) // error: ambiguous overload
+  assert(x == "x")
+}

tests/pos/capture-variance.scala

@@ -0,0 +1,13 @@
+class Hi
+class Lo extends Hi
+class Cov1[+T]
+class Cov2[+T >: Lo <: Hi]
+class Contra1[-T]
+class Contra2[-T >: Lo <: Hi]
+
+object Test {
+  val a: List[Cov1[Any]] = ??? : List[Cov1[_]]
+  val b: List[Cov2[Hi]] = ??? : List[Cov2[_]]
+  val c: List[Contra1[Nothing]] = ??? : List[Contra1[_]]
+  val d: List[Contra2[Lo]] = ??? : List[Contra2[_]]
+}

tests/run/t5729.scala

@@ -4,13 +4,4 @@ object Test extends App {
   def join[S](in: Seq[T[S]]): String = "x"
   val x = join(null: Seq[T[_]])
   assert(x == 1)  // first alt chosen, since second requires a capture conversion in adapt
-  C
-}
-
-object C {
-  def join(in: Seq[List[_]]): Int = 1
-  def join[S](in: Seq[List[S]]): String = "x"
-
-  val x= join(Seq[List[Int]]()) // second alt chosen, since it is more specific
-  assert(x == "x")
 }