Handle dependent parameters hidden behind a TypeVar

This is needed for type inference with a type variable selection (added
in the next commit of this PR) to work properly, but it also affects master.

Because dependencies can now span multiple TypeLambdas,
`addToConstraint` had to be adjusted to properly propagate all
constraints.

i5735 doesn't compile anymore but I don't think it ever really made
sense.

Author: smarter

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

@@ -445,8 +445,9 @@ trait ConstraintHandling[AbstractContext] {
             if lower.nonEmpty && !bounds.lo.isRef(defn.NothingClass)
                || upper.nonEmpty && !bounds.hi.isAny
             then constr.println(i"INIT*** $tl")
-            lower.forall(addOneBound(_, bounds.hi, isUpper = true)) &&
-              upper.forall(addOneBound(_, bounds.lo, isUpper = false))
+
+               lower.forall(loParam => addOneBound(loParam, bounds.hi, isUpper =  true) && addOneBound(param, constraint.nonParamBounds(loParam).lo, isUpper = false))
+            && upper.forall(upParam => addOneBound(upParam, bounds.lo, isUpper = false) && addOneBound(param, constraint.nonParamBounds(upParam).hi, isUpper =  true))
           case _ =>
             // Happens if param was already solved while processing earlier params of the same TypeLambda.
             // See #4720.

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

@@ -232,7 +232,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *  @param isUpper   If true, `bound` is an upper bound, else a lower bound.
    */
   private def stripParams(tp: Type, paramBuf: mutable.ListBuffer[TypeParamRef],
-      isUpper: Boolean)(implicit ctx: Context): Type = tp match {
+      isUpper: Boolean)(implicit ctx: Context): Type = tp.stripTypeVar match {
     case param: TypeParamRef if contains(param) =>
       if (!paramBuf.contains(param)) paramBuf += param
       NoType
@@ -365,7 +365,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *    Q <: tp  implies  Q <: P      and isUpper = true, or
    *    tp <: Q  implies  P <: Q      and isUpper = false
    */
-  private def dependentParams(tp: Type, isUpper: Boolean): List[TypeParamRef] = tp match
+  private def dependentParams(tp: Type, isUpper: Boolean)(using Context): List[TypeParamRef] = tp.stripTypeVar match
     case param: TypeParamRef if contains(param) =>
       param :: (if (isUpper) upper(param) else lower(param))
     case tp: AndType if isUpper  =>

tests/pos/i5735.scala renamed to tests/neg/i5735.scala

@@ -8,5 +8,5 @@ object Test {
   class Foo[T] { def apply[Y >: T <: Nested[T, Tuple2, Unit]](t: T): T = t }
   def foo[T] = new Foo[T]
 
-  foo.apply((21, ()))
+  foo.apply((21, ())) // error
 }

tests/pos/dependent-typevar.scala

@@ -0,0 +1,8 @@
+class Foo[A] {
+  // Previously, we did not record the constraint ordering `A <: B` here
+  def bar[B >: A <: String]: String = ""
+}
+object Test {
+  // ... which prevented the following from typechecking.
+  val ret = (new Foo).bar
+}