Avoi intersections in typing selections and applications

Use either the qualifier type or the result type depending on
a pre-check using a new method `mightSubcapture`.

Author: odersky

compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -111,7 +111,7 @@ sealed abstract class CaptureSet extends Showable:
   /** {x} <:< this   where <:< is subcapturing, but treating all variables
    *                 as frozen.
    */
-  def accountsFor(x: CaptureRef)(using ctx: Context): Boolean =
+  def accountsFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this accountsFor $x, ${x.captureSetOfInfo}?", show = true) {
       elems.exists(_.subsumes(x))
       || !x.isRootCapability && x.captureSetOfInfo.subCaptures(this, frozen = true).isOK
@@ -122,12 +122,19 @@ sealed abstract class CaptureSet extends Showable:
    *  for `x` in a state where we assume all supersets of `x` have just the elements
    *  known at this point.
    */
-  def mightAccountFor(x: CaptureRef)(using ctx: Context): Boolean =
+  def mightAccountFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this mightAccountFor $x, ${x.captureSetOfInfo}?", show = true) {
       elems.exists(_.subsumes(x))
       || !x.isRootCapability && x.captureSetOfInfo.elems.forall(mightAccountFor)
     }
 
+  /** A more optimistic version of subCaptures used to choose one of two typing rules
+   *  for selctions and applications. `cs1 mightSubcapture cs2` if `cs2` might account for
+   *  every element currently known to be in `cs1`.
+   */
+  def mightSubcapture(that: CaptureSet)(using Context): Boolean =
+    elems.forall(that.mightAccountFor)
+
   /** The subcapturing test */
   final def subCaptures(that: CaptureSet, frozen: Boolean)(using Context): CompareResult =
     subCaptures(that)(using ctx, if frozen then FrozenState else VarState())

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

@@ -246,8 +246,10 @@ class CheckCaptures extends Recheck, SymTransformer:
       else
         val qualCs = qualType.captureSet
         //println(i"intersect $qualType, ${selType.widen}, $qualCs, $selCs")
-        if selCs.subCaptures(qualCs, frozen = true).isOK then selType
-        else selType.widen.stripCapturing.capturing(selCs ** qualCs)
+        if qualCs.mightSubcapture(selCs) then
+          selType.widen.stripCapturing.capturing(qualCs)
+        else
+          selType
     }//.showing(i"recheck sel $tree, $qualType = $result")
 
     override def recheckClosure(tree: Closure, pt: Type)(using Context): Type =
@@ -412,13 +414,12 @@ class CheckCaptures extends Recheck, SymTransformer:
         case tp @ CapturingType(tp1, refs) =>
           tree.fun match
             case Select(qual, nme.apply)
-            if defn.isFunctionType(qual.tpe.widen) =>
-              qual.tpe match
-                case ref: CaptureRef
-                if ref.isTracked && tree.args.forall(_.tpe.captureSet.isAlwaysEmpty) =>
-                  tp.derivedCapturingType(tp1, refs ** ref.singletonCaptureSet)
-                    .showing(i"narrow $tree: $tp --> $result", capt)
-                case _ => tp
+            if defn.isFunctionType(qual.tpe.widen)
+                && tree.args.forall(_.tpe.captureSet.isAlwaysEmpty)
+                && qual.tpe.captureSet.mightSubcapture(refs)
+            =>
+              tp.derivedCapturingType(tp1, qual.tpe.captureSet)
+                .showing(i"narrow $tree: $tp --> $result", capt)
             case _ => tp
         case tp => tp