Fix type avoidance in nested Array case

Author: dwijnand

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

@@ -5856,7 +5856,7 @@ object Types {
               tp.derivedAppliedType(tycon, args.map(rangeToBounds)) match
                 case tp1: AppliedType if tp1.isUnreducibleWild =>
                   // don't infer a type that would trigger an error later in
-                  // Checling.checkAppliedType; fall through to default handling instead
+                  // Checking.checkAppliedType; fall through to default handling instead
                 case tp1 =>
                   return tp1
             end if
@@ -5865,7 +5865,7 @@ object Types {
             // non-range arguments L1, ..., Ln and H1, ..., Hn such that
             // C[L1, ..., Ln] <: C[H1, ..., Hn] by taking the right limits of
             // ranges that appear in as co- or contravariant arguments.
-            // Fail for non-variant argument ranges.
+            // Fail for non-variant argument ranges (see use-site else branch below).
             // If successful, the L-arguments are in loBut, the H-arguments in hiBuf.
             // @return  operation succeeded for all arguments.
             def distributeArgs(args: List[Type], tparams: List[ParamInfo]): Boolean = args match {
@@ -5886,8 +5886,11 @@ object Types {
             if (distributeArgs(args, tp.tyconTypeParams))
               range(tp.derivedAppliedType(tycon, loBuf.toList),
                     tp.derivedAppliedType(tycon, hiBuf.toList))
-            else range(defn.NothingType, defn.AnyType)
-              // TODO: can we give a better bound than `topType`?
+            else if tycon.isLambdaSub then
+              range(defn.NothingType, defn.AnyType)
+            else
+              // See lampepfl/dotty#14152
+              range(defn.NothingType, tp.derivedAppliedType(tycon, args.map(rangeToBounds)))
           else tp.derivedAppliedType(tycon, args)
       }
 

tests/pos/i14152.min.scala

@@ -1,6 +1,30 @@
+val a1 = {
+  object O1 extends AnyRef
+  Array(O1)
+}
+val a2: Array[_ <: AnyRef] = aa1
+
 val aa1 = {
   object O1 extends AnyRef
   Array(Array(O1))
 }
-
 val aa2: Array[_ <: Array[_ <: AnyRef]] = aa1
+
+val aaa1 = {
+  object O1 extends AnyRef
+  Array(Array(Array(O1)))
+}
+val aaa2: Array[_ <: Array[_ <: Array[_ <: AnyRef]]] = aaa1
+
+
+// Let's make sure avoidance still does the right thing given abstract type constructors
+
+class Inv[T](x: T)
+
+def foo[F[_]](fn: [A] => Inv[A] => F[A]) =
+  object O1 extends AnyRef
+  val res0 = fn(new Inv(fn(new Inv[O1.type](O1))))
+  val res1: F[F[O1.type]] = res0
+  res1 // checked with -Xprint:typer that this widens to Any
+       // instead of the original F[F[O1.type]]
+       // or the incorrectly avoided F[? <: F[? <: Object]]