Refine parameter accessors that have nonempty deep capture sets

A parameter accessor with a nonempty deep capture set needs to be tracked in refinements
even if it is pure, as long as it might contain captures that can be referenced using
a reach capability.

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

@@ -501,6 +501,9 @@ extension (sym: Symbol)
       && !param.hasAnnotation(defn.UntrackedCapturesAnnot)
     }
 
+  def hasTrackedParts(using Context): Boolean =
+    !CaptureSet.deepCaptureSet(sym.info).isAlwaysEmpty
+
 extension (tp: AnnotatedType)
   /** Is this a boxed capturing type? */
   def isBoxed(using Context): Boolean = tp.annot match

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

@@ -1090,7 +1090,7 @@ object CaptureSet:
     recur(tp)
       //.showing(i"capture set of $tp = $result", captDebug)
 
-  private def deepCaptureSet(tp: Type)(using Context): CaptureSet =
+  def deepCaptureSet(tp: Type)(using Context): CaptureSet =
     val collect = new TypeAccumulator[CaptureSet]:
       def apply(cs: CaptureSet, t: Type) = t.dealias match
         case t @ CapturingType(p, cs1) =>

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

@@ -554,7 +554,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             if core.derivesFromCapability then CaptureSet.universal else initCs
           for (getterName, argType) <- mt.paramNames.lazyZip(argTypes) do
             val getter = cls.info.member(getterName).suchThat(_.isRefiningParamAccessor).symbol
-            if !getter.is(Private) && getter.termRef.isTracked then
+            if !getter.is(Private) && getter.hasTrackedParts then
               refined = RefinedType(refined, getterName, argType)
               allCaptures ++= argType.captureSet
           (refined, allCaptures)

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

@@ -186,7 +186,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             case cls: ClassSymbol
             if !defn.isFunctionClass(cls) && cls.is(CaptureChecked) =>
               cls.paramGetters.foldLeft(tp) { (core, getter) =>
-                if atPhase(thisPhase.next)(getter.termRef.isTracked)
+                if atPhase(thisPhase.next)(getter.hasTrackedParts)
                     && getter.isRefiningParamAccessor
                     && !getter.is(Tracked)
                 then

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

@@ -846,7 +846,8 @@ object Symbols extends SymUtils {
   /** Map given symbols, subjecting their attributes to the mappings
    *  defined in the given TreeTypeMap `ttmap`.
    *  Cross symbol references are brought over from originals to copies.
-   *  Do not copy any symbols if all attributes of all symbols stay the same.
+   *  Do not copy any symbols if all attributes of all symbols stay the same
+   *  and mapAlways is false.
    */
   def mapSymbols(originals: List[Symbol], ttmap: TreeTypeMap, mapAlways: Boolean = false)(using Context): List[Symbol] =
     if (originals.forall(sym =>

tests/pos/reach-problem.scala

@@ -0,0 +1,9 @@
+import language.experimental.captureChecking
+
+class Box[T](items: Seq[T^]):
+  def getOne: T^{items*} = ???
+
+object Box:
+  def getOne[T](items: Seq[T^]): T^{items*} =
+    val bx = Box(items)
+    bx.getOne