Sharpen range approximation for applied types with capture set ranges

This is a stopgap to avoid approximating the core type to Nothing. It can probably be
dropped once we capture set ranges that we can keep as inference results.
See pos-customargs/captures/16226.scala for a test case where this matters.
The problem is what should be the approximation of the range

    C[{cs1} A .. {cs2} A]

where the type constructor `C` is non-variant? If the variance of the enclosing map
is positive, this is `C[? >: {cs1} A <: {cs2} A]`, which is a supertype of both range end
points `C[{cs1} A]` and `C[{cs2} A]`. But if the variance is negative, we would normally
fall back to `Nothing`, since that is the only known subtype of both range end points.
This reasoning seems too strict for capture checking. In a sense, we have already
inferred `C[A]` before; now we just need to find out what the set should be. What we are
after is a notion of a _capture set range_. I.e. something like

    C[{cs1}..{cs2} A]

with the meaning that the capture set of `C` is an unknown set between `cs1` and `cs2`.
We don't have that abstraction yet, so for now we approximate by the bounds, which
avoids the failures, even though its soundness status is currently unclear.

Author: odersky

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

@@ -5909,6 +5909,10 @@ object Types {
         case Range(tyconLo, tyconHi) =>
           range(derivedAppliedType(tp, tyconLo, args), derivedAppliedType(tp, tyconHi, args))
         case _ =>
+          def differsOnlyInCaptureSet(arg: Type) = arg match
+            case Range(CapturingType(lo, _), CapturingType(hi, _)) => lo eq hi
+            case Range(_, _) => false
+            case _ => true
           if args.exists(isRange) then
             if variance > 0 then
               tp.derivedAppliedType(tycon, args.map(rangeToBounds)) match
@@ -5946,6 +5950,24 @@ object Types {
                     tp.derivedAppliedType(tycon, hiBuf.toList))
             else if tycon.isLambdaSub || args.exists(isRangeOfNonTermTypes) then
               range(defn.NothingType, defn.AnyType)
+            else if ctx.phase == Phases.checkCapturesPhase && args.forall(differsOnlyInCaptureSet) then
+              // This is a stopgap to avoid approximating the core type to Nothing. It can probably be
+              // dropped once we capture set ranges that we can keep as inference results.
+              // See pos-customargs/captures/16226.scala for a test case where this matters.
+              // The problem is what should be the approximation of the range
+              //   C[{cs1} A .. {cs2} A]
+              // where the type constructor C is non-variant? If the variance of the enclosing map
+              // is positive, this is C[? >: {cs1} A <: {cs2} A], which is a supertype of both range end
+              // points C[{cs1} A] and C[{cs2} A]. But if the variance is negative, we would normally
+              // fall back to Nothing, since that is the only known subtype of both range end points.
+              // This reasoning seems too strict for capture checking. In a sense, we have already
+              // inferred C[A] before; now we just need to find out what the set should be. What we are
+              // after is a notion of a _capture set range_. I.e. something like
+              //   C[{cs1}..{cs2} A]
+              // with the meaning that the capture set of C is an unknown set between cs1 and cs2.
+              // We don't have that abstraction yet, so for now we approximate by the bounds, which
+              // avoids the failures, even though its soundness status is currently unclear.
+              tp.derivedAppliedType(tycon, args.map(rangeToBounds))
             else
               // See lampepfl/dotty#14152
               range(defn.NothingType, tp.derivedAppliedType(tycon, args.map(rangeToBounds)))
@@ -6037,14 +6059,10 @@ object Types {
   /** A range of possible types between lower bound `lo` and upper bound `hi`.
    *  Only used internally in `ApproximatingTypeMap`.
    */
-  case class Range(lo: Type, hi: Type) extends UncachedGroundType {
+  case class Range(lo: Type, hi: Type) extends UncachedGroundType:
     assert(!lo.isInstanceOf[Range])
     assert(!hi.isInstanceOf[Range])
 
-    override def toText(printer: Printer): Text =
-      lo.toText(printer) ~ ".." ~ hi.toText(printer)
-  }
-
   /** Approximate wildcards by their bounds */
   class AvoidWildcardsMap(using Context) extends ApproximatingTypeMap:
     protected def mapWild(t: WildcardType) =

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -278,6 +278,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
             case ex: Throwable => Str("...")
           }
         "LazyRef(" ~ refTxt ~ ")"
+      case Range(lo, hi) =>
+        toText(lo) ~ " .. " ~ toText(hi)
       case _ =>
         tp.fallbackToText(this)
     }

tests/pos-custom-args/captures/i16226.scala

@@ -0,0 +1,14 @@
+@annotation.capability class Cap
+
+class LazyRef[T](val elem: () => T):
+  val get: {elem} () -> T = elem
+  def map[U](f: T => U): {f, this} LazyRef[U] =
+    new LazyRef(() => f(elem()))
+
+def map[A, B](ref: {*} LazyRef[A], f: A => B): {f, ref} LazyRef[B] =
+  new LazyRef(() => f(ref.elem()))
+
+def main(io: Cap) = {
+  def mapd[A, B]: ({io} LazyRef[A], A => B) => {*} LazyRef[B] =
+    (ref1, f1) => map[A, B](ref1, f1)
+}