Update extractors

Author: noti0na1

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

@@ -603,6 +603,17 @@ object Capabilities:
     def assumedContainsOf(x: TypeRef)(using Context): SimpleIdentitySet[Capability] =
       CaptureSet.assumedContains.getOrElse(x, SimpleIdentitySet.empty)
 
+    def toType(using Context): Type = this match
+      case c: RootCapability => defn.captureRoot.termRef
+      case c: CoreCapability => c
+      case c: DerivedCapability =>
+        val c1 = c.underlying.toType
+        c match
+          case _: ReadOnly => ReadOnlyCapability(c1)
+          case _: Reach => ReachCapability(c1)
+          // TODO: do we need to handle Maybe here?
+          case _ => c1
+
     def toText(printer: Printer): Text = printer.toTextCapability(this)
   end Capability
 

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

@@ -42,10 +42,10 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
     if symbol == defn.RetainsCapAnnot then
       New(symbol.typeRef, Nil)
     else
-      val elems = refs.elems.toList
+      val elems = refs.elems.toList.map(_.toType)
       val trefs =
         if elems.isEmpty then defn.NothingType
-        else elems.reduce[Type]((a, b) => OrType(a, b, soft = false))
+        else elems.reduce((a, b) => OrType(a, b, soft = false))
       New(AppliedType(symbol.typeRef, trefs :: Nil), Nil)
 
   override def symbol(using Context) = cls

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

@@ -86,15 +86,24 @@ extension (tree: Tree)
       case Apply(TypeApply(_, refs :: Nil), _) => refs.tpe
       case _ =>
         if tree.symbol.maybeOwner == defn.RetainsCapAnnot
-        then ref(defn.captureRoot) else NoType
+        then defn.captureRoot.termRef else NoType
 
 extension (tp: Type)
 
-  def retainedElementsRaw(using Context): List[Type] = tp match
+  def toCapabilities(using Context): List[Capability] = tp match
     case ReachCapability(tp1) =>
-      tp1.reach :: Nil
+      tp1.toCapabilities.map(_.reach)
     case ReadOnlyCapability(tp1) =>
-      tp1.readOnly :: Nil
+      tp1.toCapabilities.map(_.readOnly)
+    case ref: TermRef if ref.isCapRef =>
+      GlobalCap :: Nil
+    case ref: Capability if ref.isTrackableRef =>
+      ref :: Nil
+    case _ =>
+      // if this was compiled from cc syntax, problem should have been reported at Typer
+      throw IllegalCaptureRef(tp)
+
+  def retainedElementsRaw(using Context): List[Type] = tp match
     case OrType(tp1, tp2) =>
       tp1.retainedElementsRaw ++ tp2.retainedElementsRaw
     case tp =>
@@ -103,9 +112,7 @@ extension (tp: Type)
       else tp :: Nil // should be checked by wellformedness
 
   def retainedElements(using Context): List[Capability] =
-    retainedElementsRaw.map:
-      case tp: CaptureRef => tp
-      case tp => throw IllegalCaptureRef(tp)
+    retainedElementsRaw.flatMap(_.toCapabilities)
 
   /** Is this type a Capability that can be tracked?
    *  This is true for
@@ -539,57 +546,25 @@ class CleanupRetains(using Context) extends TypeMap:
         RetainingType(tp, defn.NothingType, byName = annot.symbol == defn.RetainsByNameAnnot)
       case _ => mapOver(tp)
 
-// /** An extractor for `caps.reachCapability(ref)`, which is used to express a reach
-//  *  capability as a tree in a @retains annotation.
-//  */
-// object ReachCapabilityApply:
-//   def unapply(tree: Apply)(using Context): Option[Tree] = tree match
-//     case Apply(reach, arg :: Nil) if reach.symbol == defn.Caps_reachCapability => Some(arg)
-//     case _ => None
-
-// /** An extractor for `caps.readOnlyCapability(ref)`, which is used to express a read-only
-//  *  capability as a tree in a @retains annotation.
-//  */
-// object ReadOnlyCapabilityApply:
-//   def unapply(tree: Apply)(using Context): Option[Tree] = tree match
-//     case Apply(ro, arg :: Nil) if ro.symbol == defn.Caps_readOnlyCapability => Some(arg)
-//     case _ => None
-
 abstract class AnnotatedCapability(annotCls: Context ?=> ClassSymbol):
   def apply(tp: Type)(using Context): AnnotatedType =
-    assert(tp.isTrackableRef, i"not a trackable ref: $tp")
-    tp match
-      case AnnotatedType(_, annot) =>
-        assert(!unwrappable.contains(annot.symbol), i"illegal combination of derived capabilities: $annotCls over ${annot.symbol}")
-      case _ =>
-    tp match
-      case tp: Capability => tp.derivedRef(annotCls)
-      case _ => AnnotatedType(tp, Annotation(annotCls, util.Spans.NoSpan))
+    AnnotatedType(tp, Annotation(annotCls, util.Spans.NoSpan))
 
-  def unapply(tree: AnnotatedType)(using Context): Option[Capability] = tree match
-    case AnnotatedType(parent: Capability, ann) if ann.hasSymbol(annotCls) => Some(parent)
+  def unapply(tree: AnnotatedType)(using Context): Option[Type] = tree match
+    case AnnotatedType(parent: Type, ann) if ann.hasSymbol(annotCls) => Some(parent)
     case _ => None
 
-  protected def unwrappable(using Context): Set[Symbol]
 end AnnotatedCapability
 
-object QualifiedCapability:
-  def unapply(tree: AnnotatedType)(using Context): Option[Capability] = tree match
-    case AnnotatedType(parent: Capability, ann)
-    if defn.capabilityQualifierAnnots.contains(ann.symbol) => Some(parent)
-    case _ => None
-
 /** An extractor for `ref @readOnlyCapability`, which is used to express
  *  the read-only capability `ref.rd` as a type.
  */
-object ReadOnlyCapability extends AnnotatedCapability(defn.ReadOnlyCapabilityAnnot):
-  protected def unwrappable(using Context) = Set()
+object ReadOnlyCapability extends AnnotatedCapability(defn.ReadOnlyCapabilityAnnot)
 
 /** An extractor for `ref @annotation.internal.reachCapability`, which is used to express
  *  the reach capability `ref*` as a type.
  */
-object ReachCapability extends AnnotatedCapability(defn.ReachCapabilityAnnot):
-  protected def unwrappable(using Context) = Set(defn.ReadOnlyCapabilityAnnot)
+object ReachCapability extends AnnotatedCapability(defn.ReachCapabilityAnnot)
 
 /** An extractor for all kinds of function types as well as method and poly types.
  *  It includes aliases of function types such as `=>`. TODO: Can we do without?

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

@@ -1554,11 +1554,6 @@ class Definitions {
   @tu lazy val pureSimpleClasses =
     Set(StringClass, NothingClass, NullClass) ++ ScalaValueClasses()
 
-  @tu lazy val capabilityQualifierAnnots: Set[Symbol] =
-    Set(ReachCapabilityAnnot, ReadOnlyCapabilityAnnot)
-  @tu lazy val capabilityWrapperAnnots: Set[Symbol] =
-    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))
   def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)

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

@@ -313,7 +313,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         def arrowText: Text = restp match
           case AnnotatedType(parent, ann) if ann.symbol == defn.RetainsByNameAnnot =>
             ann.tree.retainedSet.retainedElementsRaw match
-              case (ref: CaptureRef) :: Nil if ref.isCap => Str("=>")
+              case (ref: TermRef) :: Nil if ref.symbol == defn.captureRoot => Str("=>")
               case refs => Str("->") ~ toTextRetainedElems(refs.map(r => ast.tpd.TypeTree(r)))
           case _ =>
             if Feature.pureFunsEnabled then "->" else "=>"

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

@@ -5,4 +5,4 @@ trait A
 extension (a: A^{cap.rd})
   def await = ()
 
-def awaitA[C <: {cap.rd}](a: A^{C}) = a.await
+def awaitA[C^ <: {cap.rd}](a: A^{C}) = a.await