Cleanup code

Author: noti0na1

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

@@ -59,7 +59,7 @@ extension (tree: Tree)
         refs
 
   /** The type representing the capture set of retains annotation.
-    */
+   */
   def retainedSet(using Context): Type =
     tree match
       case Apply(TypeApply(_, refs :: Nil), _) => refs.tpe
@@ -69,19 +69,22 @@ extension (tree: Tree)
 
 extension (tp: Type)
 
-  def toCapabilities(using Context): List[Capability] = tp match
+  def toCapability(using Context): Capability = tp match
     case ReachCapability(tp1) =>
-      tp1.toCapabilities.map(_.reach)
+      tp1.toCapability.reach
     case ReadOnlyCapability(tp1) =>
-      tp1.toCapabilities.map(_.readOnly)
+      tp1.toCapability.readOnly
     case ref: TermRef if ref.isCapRef =>
-      GlobalCap :: Nil
+      GlobalCap
     case ref: Capability if ref.isTrackableRef =>
-      ref :: Nil
+      ref
     case _ =>
       // if this was compiled from cc syntax, problem should have been reported at Typer
       throw IllegalCaptureRef(tp)
 
+  /** A list of raw elements of a retained set.
+   *  This will not crash even if it contains a non-wellformed Capability.
+   */
   def retainedElementsRaw(using Context): List[Type] = tp match
     case OrType(tp1, tp2) =>
       tp1.retainedElementsRaw ++ tp2.retainedElementsRaw
@@ -90,8 +93,10 @@ extension (tp: Type)
       if tp.isNothingType then Nil
       else tp :: Nil // should be checked by wellformedness
 
+  /** A list of capabilities tof a retained set.
+   */
   def retainedElements(using Context): List[Capability] =
-    retainedElementsRaw.flatMap(_.toCapabilities)
+    retainedElementsRaw.map(_.toCapability)
 
   /** Is this type a Capability that can be tracked?
    *  This is true for

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

@@ -550,8 +550,8 @@ class Definitions {
   @tu lazy val SingletonType: TypeRef = SingletonClass.typeRef
 
   @tu lazy val MaybeCapabilityAnnot: ClassSymbol =
-     completeClass(enterCompleteClassSymbol(
-       ScalaPackageClass, tpnme.maybeCapability, Final, List(StaticAnnotationClass.typeRef)))
+    completeClass(enterCompleteClassSymbol(
+      ScalaPackageClass, tpnme.maybeCapability, Final, List(StaticAnnotationClass.typeRef)))
 
   @tu lazy val CollectionSeqType: TypeRef  = requiredClassRef("scala.collection.Seq")
   @tu lazy val SeqType: TypeRef            = requiredClassRef("scala.collection.immutable.Seq")
@@ -1328,8 +1328,8 @@ class Definitions {
    */
   object ByNameFunction:
     def apply(tp: Type)(using Context): Type = tp match
-      case tp @ RetainingType(tp1, refs) if tp.annot.symbol == RetainsByNameAnnot =>
-        RetainingType(apply(tp1), refs)
+      case tp @ RetainingType(tp1, refSet) if tp.annot.symbol == RetainsByNameAnnot =>
+        RetainingType(apply(tp1), refSet)
       case _ =>
         defn.ContextFunction0.typeRef.appliedTo(tp :: Nil)
     def unapply(tp: Type)(using Context): Option[Type] = tp match

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

@@ -174,17 +174,17 @@ class PlainPrinter(_ctx: Context) extends Printer {
            //     ~ Str("?").provided(!cs.isConst)
       core ~ cs.optionalInfo
 
-  private def toTextRetainedElem[T <: Untyped](ref: Tree[T]): Text = ref match
-    case ref: RefTree[?] =>
-      ref.typeOpt match
-        case c: Capability => toTextCapability(c)
-        case _ => toText(ref)
-    case _ => toText(ref)
-
-  private def toTextRetainedElems[T <: Untyped](refs: List[Tree[T]]): Text =
+  private def toTextRetainedElem(ref: Type): Text = ref match
+    case c: Capability => toTextCapability(c)
+    case _ =>
+      try toTextCapability(ref.toCapability)
+      catch case _ =>
+        toText(ref)
+
+  private def toTextRetainedElems(refs: List[Type]): Text =
     "{" ~ Text(refs.map(ref => toTextRetainedElem(ref)), ", ") ~ "}"
 
-  type GeneralCaptureSet = CaptureSet | List[tpd.Tree]
+  type GeneralCaptureSet = CaptureSet | List[Type]
 
   protected def isUniversalCaptureSet(refs: GeneralCaptureSet): Boolean = refs match
     case refs: CaptureSet =>
@@ -203,12 +203,12 @@ class PlainPrinter(_ctx: Context) extends Printer {
         )
       isUniversal
       || !refs.elems.isEmpty && refs.elems.forall(_.isCapOrFresh) && !ccVerbose
-    case (ref: tpd.Tree) :: Nil => ref.symbol == defn.captureRoot
+    case (ref: TermRef) :: Nil => ref.symbol == defn.captureRoot
     case _ => false
 
   protected def toTextGeneralCaptureSet(refs: GeneralCaptureSet): Text = refs match
     case refs: CaptureSet => toTextCaptureSet(refs)
-    case refs: List[tpd.Tree] => toTextRetainedElems(refs)
+    case refs: List[Type] => toTextRetainedElems(refs)
 
   /** Print capturing type, overridden in RefinedPrinter to account for
    *  capturing function types.
@@ -284,10 +284,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
             && refs.isReadOnly
         then toText(parent)
         else toTextCapturing(parent, refs, boxText)
-      case tp @ RetainingType(parent, refsType) =>
-        val refs = refsType.retainedElementsRaw
+      case tp @ RetainingType(parent, refSet) =>
         if Feature.ccEnabledSomewhere then
-          toTextCapturing(parent, refs.map(r => ast.tpd.TypeTree(r)), "") ~ Str("R").provided(printDebug)
+          toTextCapturing(parent, refSet.retainedElementsRaw, "") ~ Str("R").provided(printDebug)
         else toText(parent)
       case tp: PreviousErrorType if ctx.settings.XprintTypes.value =>
         "<error>" // do not print previously reported error message because they may try to print this error type again recursively
@@ -314,7 +313,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           case AnnotatedType(parent, ann) if ann.symbol == defn.RetainsByNameAnnot =>
             ann.tree.retainedSet.retainedElementsRaw match
               case (ref: TermRef) :: Nil if ref.symbol == defn.captureRoot => Str("=>")
-              case refs => Str("->") ~ toTextRetainedElems(refs.map(r => ast.tpd.TypeTree(r)))
+              case refs => Str("->") ~ toTextRetainedElems(refs)
           case _ =>
             if Feature.pureFunsEnabled then "->" else "=>"
         changePrec(GlobalPrec)(arrowText ~ " " ~ toText(restp))