Introduce QualifiedCapability extractor

Author: odersky

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

@@ -694,6 +694,12 @@ abstract class AnnotatedCapability(annotCls: Context ?=> ClassSymbol):
   protected def unwrappable(using Context): Set[Symbol]
 end AnnotatedCapability
 
+object QualifiedCapability:
+  def unapply(tree: AnnotatedType)(using Context): Option[CaptureRef] = tree match
+    case AnnotatedType(parent: CaptureRef, ann)
+    if defn.capabilityQualifierAnnots.contains(ann.symbol) => Some(parent)
+    case _ => None
+
 /** An extractor for `ref @maybeCapability`, which is used to express
  *  the maybe capability `ref?` as a type.
  */

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

@@ -623,11 +623,7 @@ object CaptureSet:
                  |elem binder = ${elem.binder}""")
             false
           }
-        case ReachCapability(elem1) =>
-          levelOK(elem1)
-        case ReadOnlyCapability(elem1) =>
-          levelOK(elem1)
-        case MaybeCapability(elem1) =>
+        case QualifiedCapability(elem1) =>
           levelOK(elem1)
         case _ =>
           true
@@ -930,7 +926,7 @@ object CaptureSet:
 
     override def owner = givenOwner
 
-    // assert(id != 34, i"$initialHidden")
+    //assert(id != 4)
 
     private def aliasRef: AnnotatedType | Null =
       if myElems.size == 1 then

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

@@ -84,6 +84,8 @@ object root:
       ccs.rootId += 1
       ccs.rootId
 
+    //assert(id != 4)
+
     override def symbol(using Context) = defn.RootCapabilityAnnot
     override def tree(using Context) = New(symbol.typeRef, Nil)
     override def derivedAnnotation(tree: Tree)(using Context): Annotation = this

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

@@ -1561,8 +1561,10 @@ class Definitions {
   @tu lazy val pureSimpleClasses =
     Set(StringClass, NothingClass, NullClass) ++ ScalaValueClasses()
 
+  @tu lazy val capabilityQualifierAnnots: Set[Symbol] =
+    Set(ReachCapabilityAnnot, ReadOnlyCapabilityAnnot, MaybeCapabilityAnnot)
   @tu lazy val capabilityWrapperAnnots: Set[Symbol] =
-    Set(ReachCapabilityAnnot, ReadOnlyCapabilityAnnot, MaybeCapabilityAnnot, RootCapabilityAnnot)
+    capabilityQualifierAnnots + RootCapabilityAnnot
 
   @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).asInstanceOf[Array[TypeRef]]
   val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))