Revise path handling

 - Don't widen prefix type if followed by a path selection
 - When applying VAR with a prefix path p on a boxed capture set,
   replace cap with p* instead of p. This makes it clear that we
   need to charge deep capture sets on parameters and avoids
   paradoxes like this one:

      case class Box[+T](get: T)
      val b: Box[C^]

   Here, b.get <:< b, but b.get's underlying capture set is {cap} whereas
   b's underlying capture set is {}. By using b.get* instead of b.get, we
   make sure that we compare against the dcs of `b`, which is also {cap}.

Author: odersky

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

@@ -56,6 +56,10 @@ object ccConfig:
   def useSepChecks(using Context): Boolean =
     Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
 
+  /** Not used currently. Handy for trying out new features */
+  def newScheme(using Context): Boolean =
+    Feature.sourceVersion.stable.isAtLeast(SourceVersion.`3.7`)
+
 end ccConfig
 
 /** Are we at checkCaptures phase? */

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

@@ -643,7 +643,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       //   - on the LHS of assignments, or
       //   - if the qualifier or selection type is boxed, or
       //   - the selection is either a trackable capture ref or a pure type
-      if pt == LhsProto
+      if noWiden(selType, pt)
           || qualType.isBoxedCapturing
           || selWiden.isBoxedCapturing
           || selType.isTrackableRef
@@ -1496,11 +1496,14 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  Then
      *    foo: Foo { def a: C^{foo}; def b: C^{foo} }^{foo}
      */
-    private def improveCaptures(widened: Type, actual: Type)(using Context): Type = actual match
+    private def improveCaptures(widened: Type, prefix: Type)(using Context): Type = prefix match
       case ref: CaptureRef if ref.isTracked =>
         widened match
-          case CapturingType(p, refs) if ref.singletonCaptureSet.mightSubcapture(refs) =>
-            widened.derivedCapturingType(p, ref.singletonCaptureSet)
+          case widened @ CapturingType(p, refs) if ref.singletonCaptureSet.mightSubcapture(refs) =>
+            val improvedCs =
+              if widened.isBoxed then ref.reach.singletonCaptureSet
+              else ref.singletonCaptureSet
+            widened.derivedCapturingType(p, improvedCs)
               .showing(i"improve $widened to $result", capt)
           case _ => widened
       case _ => widened
@@ -1524,13 +1527,29 @@ class CheckCaptures extends Recheck, SymTransformer:
       case _ =>
         actual
 
+    /* Currently not needed since it forms part of `adapt`
+    private def improve(actual: Type, prefix: Type)(using Context): Type =
+      val widened = actual.widen.dealiasKeepAnnots
+      val improved = improveCaptures(widened, prefix).withReachCaptures(prefix)
+      if improved eq widened then actual else improved
+    */
+
+    /** An actual singleton type should not be widened if the expected type is a
+     *  LhsProto, or a singleton type, or a path selection with a stable value
+     */
+    private def noWiden(actual: Type, expected: Type)(using Context): Boolean =
+      actual.isSingleton
+      && expected.match
+          case expected: PathSelectionProto => !expected.sym.isOneOf(UnstableValueFlags)
+          case _ => expected.isSingleton || expected == LhsProto
+
     /** Adapt `actual` type to `expected` type. This involves:
      *   - narrow toplevel captures of `x`'s underlying type to `{x}` according to CC's VAR rule
      *   - narrow nested captures of `x`'s underlying type to `{x*}`
      *   - do box adaptation
      */
     def adapt(actual: Type, expected: Type, tree: Tree, boxErrors: BoxErrors)(using Context): Type =
-      if expected == LhsProto || expected.isSingleton && actual.isSingleton then
+      if noWiden(actual, expected) then
         actual
       else
         val improvedVAR = improveCaptures(actual.widen.dealiasKeepAnnots, actual)

scala2-library-cc/src/scala/collection/View.scala

@@ -151,12 +151,16 @@ object View extends IterableFactory[View] {
   object Filter {
     def apply[A](underlying: Iterable[A]^, p: A => Boolean, isFlipped: Boolean): Filter[A]^{underlying, p} =
       underlying match {
-        case filter: Filter[A]^{underlying} if filter.isFlipped == isFlipped =>
-          unsafeAssumeSeparate:
+        case filter: Filter[A] if filter.isFlipped == isFlipped =>
+          new Filter(filter.underlying, a => filter.p(a) && p(a), isFlipped)
+            .asInstanceOf[Filter[A]^{underlying, p}]
+              // !!! asInstanceOf needed once paths were added, see path-patmat-should-be-pos.scala for minimization
+        //case filter: Filter[A]^{underlying} if filter.isFlipped == isFlipped =>
+        //  unsafeAssumeSeparate:
             // See filter-iterable.scala for a test where a variant of Filter
             // works without the unsafeAssumeSeparate. But it requires significant
             // changes compared to the version here. See also Filter in colltest5.CollectionStrawManCC5_1.
-            new Filter(filter.underlying, a => filter.p(a) && p(a), isFlipped)
+        //    new Filter(filter.underlying, a => filter.p(a) && p(a), isFlipped)
         case _ => new Filter(underlying, p, isFlipped)
       }
   }

tests/neg-custom-args/captures/i21442.check

@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/i21442.scala:10:13 ------------------------------------------------------------
 10 |  val io = x.unbox // error: local reach capability {x*} leaks
    |           ^^^^^^^
-   |           Local reach capability x* leaks into capture scope of method foo.
+   |           Local reach capability x.unbox* leaks into capture scope of method foo.
    |           To allow this, the parameter x should be declared with a @use annotation
 -- Error: tests/neg-custom-args/captures/i21442.scala:17:10 ------------------------------------------------------------
 17 |  val x1: Boxed[IO^] = x // error

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

@@ -1,5 +1,4 @@
-//> using options -source 3.4
-// (to make sure we use the sealed policy)
+import caps.use
 class Unit
 object unit extends Unit
 
@@ -12,6 +11,6 @@ class Foo[T](val x: T)
 // Foo[□ Unit => T]
 type BoxedLazyVal[T] = Foo[LazyVal[T]]
 
-def force[A](v: BoxedLazyVal[A]): A =
+def force[A](@use v: BoxedLazyVal[A]): A =
   // Γ ⊢ v.x : □ {cap} Unit -> A
   v.x(unit)  // should be error: (unbox v.x)(unit), where (unbox v.x) should be untypable, now ok

tests/pending/pos-custom-args/captures/sep-pairs.scala renamed to tests/pos-custom-args/captures/sep-pairs.scala

@@ -13,16 +13,15 @@ def twoRefs(): Pair[Ref^, Ref^] =
   val r2 = Ref()
   Pair(r1, r2)
 
+/*
 def twoRefsBad(): Pair[Ref^, Ref^] =
   Pair(Ref(), Ref()) // error: universal capability cannot be included in capture set
                      // even though this is morally equivalent to `twoRefs`
-
+*/
 
 def test(io: Object^): Unit =
   val two = twoRefs()
-  val fst = two.fst // error: local reach capability two* leaks into test
-                    // first, the leakage makes no sense
-                    // second, the capture should be two.fst, not two*
+  val fst = two.fst
   val snd = two.snd
-  val three: Pair[Ref^{io}, Ref^{io}] = ???
-  val bad = three.fst
+
+  val p: Pair[Ref^, Ref^] = Pair(fst, snd)

tests/run-custom-args/captures/colltest5/CollectionStrawManCC5_1.scala

@@ -455,12 +455,14 @@ object CollectionStrawMan5 {
     object Filter:
       def apply[A](underlying: Iterable[A]^, pp: A => Boolean, isFlipped: Boolean): Filter[A]^{underlying, pp} =
         underlying match
-          case filter: Filter[A]^{underlying} =>
-            unsafeAssumeSeparate:
+          case filter: Filter[A] =>
+            new Filter(filter.underlying, a => filter.p(a) && pp(a))
+              .asInstanceOf[Filter[A]^{underlying, pp}]
+            //unsafeAssumeSeparate:
               // See filter-iterable.scala for a test where a variant of Filter
               // works without the unsafeAssumeSeparate. But it requires significant
               // changes compared to the version here.
-              new Filter(filter.underlying, a => filter.p(a) && pp(a))
+              //new Filter(filter.underlying, a => filter.p(a) && pp(a))
           case _ => new Filter(underlying, pp)
 
     case class Partition[A](val underlying: Iterable[A]^, p: A => Boolean) {