Improve printing of capturing types

Avoid explicit retains annotations also outside phase cc

Author: odersky

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

@@ -17,9 +17,13 @@ def retainedElems(tree: Tree)(using Context): List[Tree] = tree match
  case Apply(_, Typed(SeqLiteral(elems, _), _) :: Nil) => elems
  case _ => Nil
 
+class IllegalCaptureRef(tpe: Type) extends Exception
+
 extension (tree: Tree)
 
- def toCaptureRef(using Context): CaptureRef = tree.tpe.asInstanceOf[CaptureRef]
+ def toCaptureRef(using Context): CaptureRef = tree.tpe match
+ case ref: CaptureRef => ref
+ case tpe => throw IllegalCaptureRef(tpe)
 
  def toCaptureSet(using Context): CaptureSet =
  tree.getAttachment(Captures) match

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

@@ -49,6 +49,12 @@ sealed abstract class CaptureSet extends Showable:
  /** Is this capture set definitely non-empty? */
  final def isNotEmpty: Boolean = !elems.isEmpty
 
+ final def isUniversal(using Context) =
+ elems.exists {
+ case ref: TermRef => ref.symbol == defn.captureRoot
+ case _ => false
+ }
+
  /** Cast to variable. @pre: @isConst */
  def asVar: Var =
  assert(!isConst)

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

@@ -12,10 +12,20 @@ object CapturingType:
  else AnnotatedType(parent, CaptureAnnotation(refs, boxed))
 
  def unapply(tp: AnnotatedType)(using Context): Option[(Type, CaptureSet, Boolean)] =
- if ctx.phase == Phases.checkCapturesPhase && tp.annot.symbol == defn.RetainsAnnot then
+ if ctx.phase == Phases.checkCapturesPhase then EventuallyCapturingType.unapply(tp)
+ else None
+
+end CapturingType
+
+object EventuallyCapturingType:
+
+ def unapply(tp: AnnotatedType)(using Context): Option[(Type, CaptureSet, Boolean)] =
+ if tp.annot.symbol == defn.RetainsAnnot then
  tp.annot match
  case ann: CaptureAnnotation => Some((tp.parent, ann.refs, ann.boxed))
  case ann => Some((tp.parent, ann.tree.toCaptureSet, ann.tree.isBoxedCapturing))
  else None
 
-end CapturingType
+end EventuallyCapturingType
+
+

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

@@ -15,7 +15,7 @@ import util.SourcePosition
 import scala.util.control.NonFatal
 import scala.annotation.switch
 import config.Config
-import cc.{CapturingType, CaptureSet}
+import cc.{EventuallyCapturingType, CaptureSet}
 
 class PlainPrinter(_ctx: Context) extends Printer {
 
@@ -140,6 +140,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
  + defn.ObjectClass
  + defn.FromJavaObjectSymbol
 
+ def toText(cs: CaptureSet): Text =
+ "{" ~ Text(cs.elems.toList.map(toTextCaptureRef), ", ") ~ "}"
+
  def toText(tp: Type): Text = controlled {
  homogenize(tp) match {
  case tp: TypeType =>
@@ -189,7 +192,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
  keywordStr(" match ") ~ "{" ~ casesText ~ "}" ~
  (" <: " ~ toText(bound) provided !bound.isAny)
  }.close
- case CapturingType(parent, refs, boxed) =>
+ case EventuallyCapturingType(parent, refs, boxed) =>
  def box = Str("box ") provided boxed
  if printDebug && !refs.isConst then
  changePrec(GlobalPrec)(box ~ s"$refs " ~ toText(parent))
@@ -198,11 +201,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
  else if !refs.isConst && refs.elems.isEmpty then
  changePrec(GlobalPrec)("?" ~ " " ~ toText(parent))
  else if Config.printCaptureSetsAsPrefix then
- changePrec(GlobalPrec)(
- box ~ "{"
- ~ Text(refs.elems.toList.map(toTextCaptureRef), ", ")
- ~ "} "
- ~ toText(parent))
+ changePrec(GlobalPrec)(box ~ toText(refs) ~ " " ~ toText(parent))
  else
  changePrec(InfixPrec)(toText(parent) ~ " retains " ~ box ~ toText(refs.toRetainsTypeArg))
  case tp: PreviousErrorType if ctx.settings.XprintTypes.value =>

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

@@ -15,7 +15,7 @@ import Annotations.Annotation
 import Denotations._
 import SymDenotations._
 import StdNames.{nme, tpnme}
-import ast.{Trees, untpd}
+import ast.{Trees, tpd, untpd}
 import typer.{Implicits, Namer, Applications}
 import typer.ProtoTypes._
 import Trees._
@@ -25,10 +25,12 @@ import NameKinds.{WildcardParamName, DefaultGetterName}
 import util.Chars.isOperatorPart
 import transform.TypeUtils._
 import transform.SymUtils._
+import config.Config
 
 import language.implicitConversions
 import dotty.tools.dotc.util.{NameTransformer, SourcePosition}
 import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
+import cc.{EventuallyCapturingType, CaptureSet, toCaptureSet, IllegalCaptureRef}
 
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
@@ -602,7 +604,17 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
  case tree: Template =>
  toTextTemplate(tree)
  case Annotated(arg, annot) =>
- toTextLocal(arg) ~~ annotText(annot.symbol.enclosingClass, annot)
+ def captureSet =
+ annot.asInstanceOf[tpd.Tree].toCaptureSet
+ def toTextAnnot =
+ toTextLocal(arg) ~~ annotText(annot.symbol.enclosingClass, annot)
+ def toTextRetainsAnnot =
+ try changePrec(GlobalPrec)(toText(captureSet) ~ " " ~ toText(arg))
+ catch case ex: IllegalCaptureRef => toTextAnnot
+ if annot.symbol.maybeOwner == defn.RetainsAnnot
+ && ctx.settings.Ycc.value && Config.printCaptureSetsAsPrefix && !printDebug
+ then toTextRetainsAnnot
+ else toTextAnnot
  case EmptyTree =>
  "<empty>"
  case TypedSplice(t) =>

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

@@ -138,6 +138,9 @@ class CheckCaptures extends Recheck:
  case _ =>
  tp
 
+ /** Turn plain function types into dependent function types, so that
+ * we can refer to the parameter in capture sets
+ */
  def addFunctionRefinements(tp: Type): Type = tp match
  case tp @ AppliedType(tycon, args) =>
  if defn.isNonRefinedFunction(tp) then