Fix bounds propagation

The previous type parameter representation in terms of type members
achieved bounds propagation by waiting until a type member was selected
and then taking original bounds and refinements together as its info.
This no longer works with explicit applications. Instead, we need to
propagate bounds into wildcard arguments explicitly, when a type
application is created.

Also, fix argument computation in asSeenFrom

Author: odersky

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

@@ -405,14 +405,51 @@ class TypeApplications(val self: Type) extends AnyVal {
         }
       case nil => t
     }
+    val stripped = self.stripTypeVar
+    val dealiased = stripped.safeDealias
+
+    /** Normalize a TypeBounds argument. This involves (1) propagating bounds
+     *  from the type parameters into the argument, (2) possibly choosing the argument's
+     *  upper or lower bound according to variance.
+     *
+     *  Bounds propagation works as follows: If the dealiased type constructor is a TypeRef
+     *  `p.c`,
+     *    - take the type paramater bounds of `c` as seen from `p`,
+     *    - substitute concrete (non-bound) arguments for corresponding formal type parameters,
+     *    - interpolate, so that any (F-bounded) type parameters in the resulting bounds are avoided.
+     *  The resulting bounds are joined (via &) with corresponding type bound arguments.
+     */
     def normalizeWildcardArg(arg: Type, tparam: TypeParamInfo): Type = arg match {
       case TypeBounds(lo, hi) =>
         val v = tparam.paramVariance
-        if (v > 0) hi else if (v < 0) lo else arg
+        val avoidParams = new ApproximatingTypeMap {
+          variance = v
+          def apply(t: Type) = t match {
+            case t: TypeRef if typParams contains t.symbol =>
+              val bounds = apply(t.info).bounds
+              range(bounds.lo, bounds.hi)
+            case _ => mapOver(t)
+          }
+        }
+        val pbounds = dealiased match {
+          case dealiased @ TypeRef(prefix, _) =>
+            val (concreteArgs, concreteParams) = // @!!! optimize?
+              args.zip(typeParams.asInstanceOf[List[TypeSymbol]])
+                .filter(!_._1.isInstanceOf[TypeBounds])
+                .unzip
+            avoidParams(
+              tparam.paramInfo.asSeenFrom(prefix, tparam.asInstanceOf[TypeSymbol].owner)
+                .subst(concreteParams, concreteArgs)).orElse(TypeBounds.empty)
+          case _ =>
+            TypeBounds.empty
+        }
+        //typr.println(i"normalize arg $arg for $tparam in $self app $args%, %, pbounds, = $pbounds")
+        if (v > 0) hi & pbounds.hiBound
+        else if (v < 0) lo | pbounds.loBound
+        else arg & pbounds
       case _ => arg
     }
-    val stripped = self.stripTypeVar
-    val dealiased = stripped.safeDealias
+
     if (args.isEmpty || ctx.erasedTypes) self
     else dealiased match {
       case dealiased: HKTypeLambda =>

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

@@ -46,47 +46,44 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
               toPrefix(pre.select(nme.PACKAGE), cls, thiscls)
             else
               toPrefix(pre.baseType(cls).normalizedPrefix, cls.owner, thiscls)
-      }
+        }
       }
 
-    def argForParam(pre: Type, tparam: Symbol): Type = {
-      val tparamCls = tparam.owner
-      pre.baseType(tparamCls) match {
-        case AppliedType(_, allArgs) =>
-          var tparams = tparamCls.typeParams
-          var args = allArgs
-          var idx = 0
-          while (tparams.nonEmpty && args.nonEmpty) {
-            if (tparams.head.eq(tparam))
-              return args.head match {
-                case bounds: TypeBounds =>
-                  val v = variance
-                  if (v > 0) bounds.hi
-                  else if (v < 0) bounds.lo
-                  else TypeArgRef(pre, cls.typeRef, idx)
-                case arg => arg
-              }
-            tparams = tparams.tail
-            args = args.tail
-            idx += 1
-          }
-          throw new AssertionError(ex"$pre contains no matching argument for ${tparam.showLocated} ")
-        case OrType(tp1, tp2) => argForParam(tp1, cls) | argForParam(tp2, cls)
-        case AndType(tp1, tp2) => argForParam(tp1, cls) & argForParam(tp2, cls)
-        case _ => tp
+      def argForParam(pre: Type, tparam: Symbol): Type = {
+        val tparamCls = tparam.owner
+        pre.baseType(tparamCls) match {
+          case AppliedType(_, allArgs) =>
+            var tparams = tparamCls.typeParams
+            var args = allArgs
+            var idx = 0
+            while (tparams.nonEmpty && args.nonEmpty) {
+              if (tparams.head.eq(tparam))
+                return args.head match {
+                  case bounds: TypeBounds =>
+                    val v = variance
+                    if (v > 0) bounds.hi
+                    else if (v < 0) bounds.lo
+                    else TypeArgRef(pre, cls.typeRef, idx)
+                  case arg => arg
+                }
+              tparams = tparams.tail
+              args = args.tail
+              idx += 1
+            }
+            throw new AssertionError(ex"$pre contains no matching argument for ${tparam.showLocated} ")
+          case OrType(tp1, tp2) => argForParam(tp1, cls) | argForParam(tp2, cls)
+          case AndType(tp1, tp2) => argForParam(tp1, cls) & argForParam(tp2, cls)
+          case _ => tp
+        }
       }
-    }
 
       /*>|>*/ ctx.conditionalTraceIndented(TypeOps.track, s"asSeen ${tp.show} from (${pre.show}, ${cls.show})", show = true) /*<|<*/ { // !!! DEBUG
         tp match {
           case tp: NamedType =>
             val sym = tp.symbol
             if (sym.isStatic) tp
-            else {
-              val pre1 = atVariance(variance max 0)(this(tp.prefix))
-              if (Config.newScheme && sym.is(TypeParam)) argForParam(pre1, sym)
-              else derivedSelect(tp, pre1)
-            }
+            else if (Config.newScheme && sym.is(TypeParam)) argForParam(pre, sym)
+            else derivedSelect(tp, atVariance(variance max 0)(this(tp.prefix)))
           case tp: ThisType =>
             toPrefix(pre, cls, tp.cls)
           case _: BoundType | NoPrefix =>