Fix #5844: Sanitize base type before substituting wildcard arguments

Author: odersky

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

@@ -1727,6 +1727,40 @@ object SymDenotations {
         baseTp
       }
 
+      /** Sanitize base type so that wildvard arguments can be safely handled by
+       *  substitution. If base type is of the form `B[S_1, ..., S_n]`, then
+       *  for every `S_i:
+       *    for every wildcard argument args_j in `args`:
+       *       if the corresponding parameter `tparam_j` is referenced by `S_i`,
+       *       but `S_i != tparam_j`, then
+       *       replace S_i with `_`.
+       *
+       *  This prevents a non-sensical substitution of `tparam_j` in `S_i` by a wildcard
+       *  type (of class TypeBounds). See pos/i5844.scala as a test case.
+       */
+      def handleWildcards(base: Type, tparams: List[Symbol], args: List[Type]): Type = {
+        def sanitize(baseArg: Type, tparams: List[Symbol], args: List[Type]): Type = args match {
+          case arg :: args1 =>
+            val tparam :: tparams1 = tparams
+            val pref = tparam.typeRef
+            val baseArg1 = arg match {
+              case arg: TypeBounds if baseArg != pref && pref.occursIn(baseArg) =>
+                TypeBounds.empty
+              case _ =>
+                baseArg
+            }
+            sanitize(baseArg1, tparams1, args1)
+          case nil =>
+            baseArg
+        }
+        base match {
+          case base @ AppliedType(tycon, baseArgs) =>
+            base.derivedAppliedType(tycon, baseArgs.mapconserve(sanitize(_, tparams, args)))
+          case _ =>
+            base
+        }
+      }
+
       def recur(tp: Type): Type = try {
         tp match {
           case tp: CachedType =>
@@ -1790,7 +1824,10 @@ object SymDenotations {
                   case LambdaParam(_, _) :: _ =>
                     recur(tp.superType)
                   case tparams: List[Symbol @unchecked] =>
-                    recur(tycon).subst(tparams, args)
+                    var base = recur(tycon)
+                    if (args.exists(_.isInstanceOf[TypeBounds]))
+                      base = handleWildcards(base, tparams, args)
+                    base.subst(tparams, args)
                 }
               record(tp, baseTp)
               baseTp

tests/pos/i5844.scala

@@ -0,0 +1,11 @@
+trait A
+trait B[X, Y]{
+  def m(): X
+}
+trait C[X] extends B[X, X & A]
+
+object O{
+  def m(c: C[_]) = {
+    val x = c.m()
+  }
+}