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.

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/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[_]]
+}