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

@@ -2162,6 +2162,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!*
@@ -2174,12 +2183,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))
  }