Fix #5844: Sanitize base type before substituting wildcard arguments

Author: odersky

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

@@ -1727,6 +1727,58 @@ 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`,
+       *       and the reference does not itself appear in argument position, 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 problemRef = new TypeAccumulator[Boolean] {
+              // Does `tp` contain a reference to `tparam` that does not appear itself
+              // in argument position of an AppliedType with a class constructor?
+              def apply(x: Boolean, tp: Type): Boolean =
+                x || {
+                  tp match {
+                    case tp @ TypeRef(prefix, _) =>
+                      tp.symbol == tparam || apply(x, prefix)
+                    case AppliedType(tycon, args) if tycon.typeSymbol.isClass =>
+                      apply(x, tycon) || args.exists(foldOver(x, _))
+                    case _ =>
+                      foldOver(x, tp)
+                  }
+                }
+            }
+            def isParamRef(tp: Type) = tp match {
+              case tp: TypeRef => tp.symbol == tparam
+              case _ => false
+            }
+            val baseArg1 = arg match {
+              case arg: TypeBounds if !isParamRef(baseArg) && problemRef(false, 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 +1842,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()
+  }
+}