Streamline treatment of CaptureRefs

 - use isTrackableRef everywhere for discrimination (instead of
   just checking the CaptureRef type)
 - streamline treatment of reach refs through `stripReach`

Author: odersky

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

@@ -63,7 +63,7 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
     val elems = refs.elems.toList
     val elems1 = elems.mapConserve(tm)
     if elems1 eq elems then this
-    else if elems1.forall(_.isInstanceOf[CaptureRef])
+    else if elems1.forall(_.isTrackableRef)
     then derivedAnnotation(CaptureSet(elems1.asInstanceOf[List[CaptureRef]]*), boxed)
     else EmptyAnnotation
 

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

@@ -78,7 +78,7 @@ extension (tree: Tree)
 
   /** Map tree with CaptureRef type to its type, throw IllegalCaptureRef otherwise */
   def toCaptureRef(using Context): CaptureRef = tree.tpe match
-    case ref: CaptureRef => ref
+    case ref: CaptureRef if ref.isTrackableRef => ref
     case tpe => throw IllegalCaptureRef(tpe) // if this was compiled from cc syntax, problem should have been reported at Typer
 
   /** Convert a @retains or @retainsByName annotation tree to the capture set it represents.

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

@@ -156,12 +156,8 @@ sealed abstract class CaptureSet extends Showable:
           case y: TermRef => !y.isReach && (y.prefix eq x)
           case _ => false
       || x.match
-          case x: TermRef if x.isReach =>
-            y.match
-              case y: TermRef if y.isReach => x.reachPrefix.subsumes(y.reachPrefix)
-              case _ => x.reachPrefix.subsumes(y)
-          case _ =>
-            false
+          case x: TermRef if x.isReach => x.stripReach.subsumes(y.stripReach)
+          case _ => false
 
   /** {x} <:< this   where <:< is subcapturing, but treating all variables
    *                 as frozen.
@@ -505,7 +501,7 @@ object CaptureSet:
       if elem.isRootCapability then !noUniversal
       else elem match
         case elem: TermRef =>
-          if elem.isReach then levelOK(elem.reachPrefix)
+          if elem.isReach then levelOK(elem.stripReach)
           else if levelLimit.exists then
             var sym = elem.symbol
             if sym.isLevelOwner then sym = sym.owner

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

@@ -1249,15 +1249,15 @@ class CheckCaptures extends Recheck, SymTransformer:
       val checker = new TypeTraverser:
         private var allowed: SimpleIdentitySet[TermParamRef] = SimpleIdentitySet.empty
 
-        private def isAllowed(ref: CaptureRef): Boolean = ref match
+        private def isAllowed(ref: CaptureRef): Boolean = ref.stripReach match
           case ref: TermParamRef => allowed.contains(ref)
           case _ => true
 
         private def healCaptureSet(cs: CaptureSet): Unit =
           cs.ensureWellformed: elem =>
             ctx ?=>
               var seen = new util.HashSet[CaptureRef]
-              def recur(ref: CaptureRef): Unit = ref match
+              def recur(ref: CaptureRef): Unit = ref.stripReach match
                 case ref: TermParamRef
                 if !allowed.contains(ref) && !seen.contains(ref) =>
                   seen += ref

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

@@ -2177,6 +2177,8 @@ object Types {
     /** Is this a reach reference of the form `x*`? */
     def isReach(using Context): Boolean = false // overridden in TermRef
 
+    def stripReach(using Context): CaptureRef = this // overridden in TermRef
+
     /** Is this reference the generic root capability `cap` ? */
     def isRootCapability(using Context): Boolean = false
 
@@ -2916,13 +2918,14 @@ object Types {
     override def isReach(using Context): Boolean =
       name == nme.CC_REACH && symbol == defn.Any_ccReach
 
-    def reachPrefix: CaptureRef = prefix.asInstanceOf[CaptureRef]
+    override def stripReach(using Context): CaptureRef =
+      if isReach then prefix.asInstanceOf[CaptureRef] else this
 
     override def isRootCapability(using Context): Boolean =
       name == nme.CAPTURE_ROOT && symbol == defn.captureRoot
 
     override def normalizedRef(using Context): CaptureRef =
-      if isReach then TermRef(reachPrefix.normalizedRef, name, denot)
+      if isReach then TermRef(stripReach.normalizedRef, name, denot)
       else if isTrackableRef then symbol.termRef
       else this
   }

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

@@ -377,7 +377,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
   def toTextRef(tp: SingletonType): Text = controlled {
     tp match {
       case tp: TermRef =>
-        if tp.isReach then toTextRef(tp.reachPrefix) ~ "*"
+        if tp.isReach then toTextRef(tp.stripReach) ~ "*"
         else toTextPrefixOf(tp) ~ selectionString(tp)
       case tp: ThisType =>
         nameString(tp.cls) + ".this"