Add a subtype check with Wildcard types

This breaks tests/run/typeclass-derivation2c.scala
There is no way to statically know that the type passed to constValue reduces.

Author: OlivierBlanvillain

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

@@ -405,7 +405,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case dealiased: LazyRef =>
         LazyRef(c => dealiased.ref(c).appliedTo(args))
       case dealiased: WildcardType =>
-        WildcardType(dealiased.optBounds.appliedTo(args).bounds)
+        WildcardType(dealiased.optBounds.orElse(TypeBounds.empty).appliedTo(args).bounds)
       case dealiased: TypeRef if dealiased.symbol == defn.NothingClass =>
         dealiased
       case dealiased =>

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

@@ -2152,6 +2152,15 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
         case _ =>
           cas
       }
+      def widenAbstractTypes(tp: Type) = new TypeMap {
+        def apply(tp: Type) = tp match {
+          case tp: TypeRef if tp.symbol.isAbstractOrParamType | tp.symbol.isOpaqueAlias => WildcardType
+          case tp: TypeVar if !tp.isInstantiated => WildcardType
+          case _: SkolemType | _: TypeParamRef => WildcardType
+          case _ => mapOver(tp)
+        }
+      }.apply(tp)
+
       val defn.MatchCase(pat, body) = cas1
       if (isSubType(scrut, pat))
         // `scrut` is a subtype of `pat`: *It's a Match!*
@@ -2164,12 +2173,14 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
               body
           }
         }
-      else if (intersecting(scrut, pat))
+      else if (isSubType(widenAbstractTypes(scrut), widenAbstractTypes(pat)))
         Some(NoType)
-      else
+      else if (!intersecting(scrut, pat))
         // We found a proof that `scrut` and  `pat` are incompatible.
         // The search continues.
         None
+      else
+        Some(NoType)
     }
 
     def recur(cases: List[Type]): Type = cases match {

tests/neg/6314-1.scala

@@ -0,0 +1,26 @@
+object G {
+  final class X
+  final class Y
+
+  trait FooSig {
+    type Type
+    def apply[F[_]](fa: F[X & Y]): F[Y & Type]
+  }
+  val Foo: FooSig = new FooSig {
+    type Type = X & Y
+    def apply[F[_]](fa: F[X & Y]): F[Y & Type] = fa
+  }
+  type Foo = Foo.Type
+
+  type Bar[A] = A match {
+    case X & Y => String
+    case Y => Int
+  }
+
+  def main(args: Array[String]): Unit = {
+    val a: Bar[X & Y] = "hello"
+    val i: Bar[Y & Foo] = Foo.apply[Bar](a)
+    val b: Int = i // error
+    println(b + 1)
+  }
+}

tests/run/typeclass-derivation2c.scala

@@ -305,8 +305,9 @@ object Pickler {
     }
 
   inline def unpickleProduct[T](g: Generic.Product[T])(buf: mutable.ListBuffer[Int]): T = {
-    inline val size = constValue[Tuple.Size[g.ElemTypes]]
-    val elems = new Array[Object](size)
+    // inline val size = constValue[Tuple.Size[g.ElemTypes]]
+    // val elems = new Array[Object](size)
+    val elems = new Array[Object](buf.size)
     unpickleElems[g.ElemTypes](0)(buf, elems)
     g.fromProduct(ArrayProduct(elems))
   }