Fix #6146: Fix bounds check involving wildcards and f-bounds

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

@@ -265,10 +265,8 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       def checkOverlapsBounds(lo: Type, hi: Type): Unit = {
         //println(i"instantiating ${bounds.hi} with $argTypes")
         //println(i" = ${instantiate(bounds.hi, argTypes)}")
-        val hiBound = instantiate(bounds.hi, argTypes.mapConserve(_.bounds.hi))
-        val loBound = instantiate(bounds.lo, argTypes.mapConserve(_.bounds.lo))
-          // Note that argTypes can contain a TypeBounds type for arguments that are
-          // not fully determined. In that case we need to check against the hi bound of the argument.
+        val hiBound = instantiate(bounds.hi, argTypes)
+        val loBound = instantiate(bounds.lo, argTypes)
         if (!(lo <:< hiBound)) violations += ((arg, "upper", hiBound))
         if (!(loBound <:< hi)) violations += ((arg, "lower", bounds.lo))
       }

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -75,8 +75,12 @@ object Checking {
     }.getOrElse(TypeTree(tparam.paramRef))
     val orderedArgs = if (hasNamedArg(args)) tparams.map(argNamed) else args
     val bounds = tparams.map(_.paramInfoAsSeenFrom(tree.tpe).bounds)
-    def instantiate(bound: Type, args: List[Type]) =
-      HKTypeLambda.fromParams(tparams, bound).appliedTo(args)
+    def instantiate(bound: Type, args: List[Type]) = tparams match {
+      case (_: Symbol) :: _ if args.exists(_.isInstanceOf[TypeBounds]) =>
+        bound.substApprox(tparams.asInstanceOf[List[Symbol]], args)
+      case _ =>
+        HKTypeLambda.fromParams(tparams, bound).appliedTo(args)
+    }
     if (boundsCheck) checkBounds(orderedArgs, bounds, instantiate)
 
     def checkWildcardApply(tp: Type): Unit = tp match {

tests/pos/i6146.scala

@@ -0,0 +1,13 @@
+trait BS[T, S <: BS[T, S]]
+ trait IS extends BS[Int, IS]
+
+sealed trait BSElem[T, S <: BS[_, S]]
+  // old error: Type argument S does not conform to upper bound BS[Any, LazyRef(S)]
+
+object BSElem {
+  implicit val intStreamShape: BSElem[Int, IS] = ???
+}
+class Ops[A] {
+  def asJavaSeqStream[S <: BS[_, S]](implicit s: BSElem[A, S]): S = ???
+    // old error: Type argument S does not conform to upper bound BS[Any, LazyRef(S)]
+}