Explain root capabilities in error messages

Author: odersky

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

@@ -15,9 +15,6 @@ import CaptureSet.VarState
 /** Attachment key for capturing type trees */
 private val Captures: Key[CaptureSet] = Key()
 
-/** Context property to print root.Fresh(...) as "fresh" instead of "cap" */
-val PrintFresh: Key[Unit] = Key()
-
 /** Are we at checkCaptures phase? */
 def isCaptureChecking(using Context): Boolean =
   ctx.phaseId == Phases.checkCapturesPhase.id

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

@@ -373,8 +373,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                 case added: CaptureRef => target.elems += added
                 case added: CaptureSet => target.elems ++= added.elems
             case _ =>
-              inContext(root.printContext(added, res.blocking)):
-                report.error(msg(provisional = false), pos)
+              report.error(msg(provisional = false), pos)
         case _ =>
 
     /** Check subcapturing `{elem} <: cs`, report error on failure */
@@ -1325,9 +1324,8 @@ class CheckCaptures extends Recheck, SymTransformer:
           actualBoxed
         case fail: CompareFailure =>
           capt.println(i"conforms failed for ${tree}: $actual vs $expected")
-          inContext(root.printContext(actualBoxed, expected1)):
-            err.typeMismatch(tree.withType(actualBoxed), expected1,
-                addApproxAddenda(
+          err.typeMismatch(tree.withType(actualBoxed), expected1,
+              addApproxAddenda(
                   addenda ++ errorNotes(fail.errorNotes),
                   expected1))
           actual

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

@@ -328,30 +328,4 @@ object root:
           throw ex
   end toResultInResults
 
-  /** If `refs` contains an occurrence of `cap` or `cap.rd`, the current context
-   *  with an added property PrintFresh. This addition causes all occurrences of
-   *  `Fresh` to be printed as `fresh` instead of `cap`, so that one avoids
-   *  confusion in error messages.
-   */
-  def printContext(refs: (Type | CaptureSet)*)(using Context): Context =
-    def hasCap = new TypeAccumulator[Boolean]:
-      def apply(x: Boolean, t: Type) =
-        x || t.dealiasKeepAnnots.match
-          case Fresh(_) => false
-          case t: TermRef => t.isCap || this(x, t.widen)
-          case CapturingType(t1, refs) => refs.containsCap || this(x, t1)
-          case x: ThisType => false
-          case _ => foldOver(x, t)
-
-    def containsCap(x: Type | CaptureSet): Boolean = x match
-      case tp: Type =>
-        hasCap(false, tp)
-      case refs: CaptureSet =>
-        refs.elems.exists(_.stripReadOnly.isCap)
-
-    if refs.exists(containsCap) then
-      ctx.withProperty(PrintFresh, Some(()))
-    else
-      ctx
-  end printContext
 end root

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

@@ -31,9 +31,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
   /** Print Fresh instances as <cap hiding ...> */
   protected def ccVerbose = ctx.settings.YccVerbose.value
 
-  /** Print Fresh instances as "fresh" */
-  protected def printFresh = ccVerbose || ctx.property(PrintFresh).isDefined
-
   private var openRecs: List[RecType] = Nil
 
   protected def maxToTextRecursions: Int = 100
@@ -192,7 +189,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       val isUniversal =
         refs.elems.size == 1
         && (refs.isUniversal
-            || !printDebug && !printFresh && !showUniqueIds && refs.elems.nth(0).match
+            || !printDebug && !ccVerbose && !showUniqueIds && refs.elems.nth(0).match
                   case root.Result(binder) =>
                     CCState.openExistentialScopes match
                       case b :: _ => binder eq b
@@ -201,7 +198,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
                     false
         )
       isUniversal
-      || !refs.elems.isEmpty && refs.elems.forall(_.isCapOrFresh) && !printFresh
+      || !refs.elems.isEmpty && refs.elems.forall(_.isCapOrFresh) && !ccVerbose
     case (ref: tpd.Tree) :: Nil => ref.symbol == defn.captureRoot
     case _ => false
 
@@ -466,12 +463,12 @@ class PlainPrinter(_ctx: Context) extends Printer {
         val vbleText: Text = CCState.openExistentialScopes.indexOf(binder) match
           case -1 =>
             "<cap of " ~ toText(binder) ~ ">"
-          case n => "outer_" * n ++ (if printFresh then "localcap" else "cap")
+          case n => "outer_" * n ++ (if ccVerbose then "localcap" else "cap")
         vbleText ~ hashStr(binder) ~ Str(idStr).provided(showUniqueIds)
       case tp @ root.Fresh(hidden) =>
         val idStr = if showUniqueIds then s"#${tp.rootAnnot.id}" else ""
         if ccVerbose then s"<fresh$idStr hiding " ~ toTextCaptureSet(hidden) ~ ">"
-        else if printFresh then "fresh"
+        else if ccVerbose then "fresh"
         else "cap"
       case tp => toText(tp)
 

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

@@ -156,7 +156,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       else simpleNameString(tsym)
     }
 
-  private def arrow(isGiven: Boolean, isPure: Boolean): String =
+  protected def arrow(isGiven: Boolean, isPure: Boolean): String =
     (if isGiven then "?" else "") + (if isPure then "->" else "=>")
 
   private def toTextFunction(tp: AppliedType, refs: GeneralCaptureSet | Null): Text =
@@ -197,7 +197,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if cc.isCaptureCheckingOrSetup
             && tp.allParamNamesSynthetic
             && !tp.looksResultDependent && !tp.looksParamDependent
-            && !showUniqueIds && !printDebug && !printFresh
+            && !showUniqueIds && !printDebug && !ccVerbose
         then
           // cc.Setup converts all functions to dependent functions. Undo that when printing.
           toTextFunction(tp.paramInfos, tp.resType, tp, refs, isContextual, isPure)

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

@@ -137,7 +137,7 @@ object Texts {
       case _ => relems.foldLeft(-1)((acc, relem) => acc max relem.maxLine)
     }
 
-    def mkString(width: Int, withLineNumbers: Boolean): String = {
+    def mkString(width: Int = Int.MaxValue, withLineNumbers: Boolean = false): String = {
       val sb = new StringBuilder
       val numberWidth = if (withLineNumbers) (2 * maxLine.toString.length) + 2 else 0
       layout(width - numberWidth).print(sb, numberWidth)

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -8,6 +8,7 @@ import printing.{RefinedPrinter, MessageLimiter, ErrorMessageLimiter}
 import printing.Texts.Text
 import printing.Formatting.hl
 import config.SourceVersion
+import cc.{CaptureRef, CaptureSet, root}
 
 import scala.language.unsafeNulls
 import scala.annotation.threadUnsafe
@@ -40,7 +41,7 @@ object Message:
       i"\n$what can be rewritten automatically under -rewrite $optionStr."
     else ""
 
-  private type Recorded = Symbol | ParamRef | SkolemType
+  private type Recorded = Symbol | ParamRef | SkolemType | CaptureRef
 
   private case class SeenKey(str: String, isType: Boolean)
 
@@ -132,7 +133,7 @@ object Message:
     end record
 
     /** Create explanation for single `Recorded` type or symbol */
-    private def explanation(entry: AnyRef)(using Context): String =
+    private def explanation(entry: AnyRef, key: String)(using Context): String =
       def boundStr(bound: Type, default: ClassSymbol, cmp: String) =
         if (bound.isRef(default)) "" else i"$cmp $bound"
 
@@ -152,7 +153,7 @@ object Message:
           ""
       }
 
-      entry match {
+      entry match
         case param: TypeParamRef =>
           s"is a type variable${addendum("constraint", TypeComparer.bounds(param))}"
         case param: TermParamRef =>
@@ -166,7 +167,25 @@ object Message:
           s"is a ${ctx.printer.kindString(sym)}${sym.showExtendedLocation}${addendum("bounds", info)}"
         case tp: SkolemType =>
           s"is an unknown value of type ${tp.widen.show}"
-      }
+        case ref: CaptureRef =>
+          val relation =
+            if List("^", "=>", "?=>").exists(key.startsWith) then "refers to"
+            else "is"
+          def ownerStr(owner: Symbol): String =
+            if owner.isConstructor then
+              i"constructor of ${ownerStr(owner.owner)}"
+            else if owner.isAnonymousFunction then
+              i"anonymous fucntion of type ${owner.info}"
+            else if owner.name.toString.contains('$') then
+              ownerStr(owner.owner)
+            else
+              owner.show
+          val descr =
+            if ref.isCap then "the universal root capability"
+            else ref match
+              case root.Fresh(hidden) => i"a fresh root capability created in ${ownerStr(hidden.owner)}"
+              case root.Result(binder) => i"a root capability associated with the result type of $binder"
+          s"$relation $descr"
     end explanation
 
     /** Produce a where clause with explanations for recorded iterms.
@@ -177,6 +196,7 @@ object Message:
         case param: ParamRef     => false
         case skolem: SkolemType  => true
         case sym: Symbol         => ctx.gadt.contains(sym) && ctx.gadt.fullBounds(sym) != TypeBounds.empty
+        case ref: CaptureRef     => ref.isRootCapability
       }
 
       val toExplain: List[(String, Recorded)] = seen.toList.flatMap { kvs =>
@@ -201,7 +221,7 @@ object Message:
         }
       }
 
-      val explainParts = toExplain.map { case (str, entry) => (str, explanation(entry)) }
+      val explainParts = toExplain.map { case (str, entry) => (str, explanation(entry, str)) }
       val explainLines = columnar(explainParts)
       if (explainLines.isEmpty) "" else i"where:    $explainLines%\n          %\n"
     end explanations
@@ -225,6 +245,25 @@ object Message:
       case tp: SkolemType => seen.record(tp.repr.toString, isType = true, tp)
       case _ => super.toTextRef(tp)
 
+    override def toTextCaptureRef(tp: Type): Text = tp match
+      case tp: CaptureRef if tp.isRootCapability && !tp.isReadOnly =>
+        seen.record("cap", isType = false, tp)
+      case _ => super.toTextCaptureRef(tp)
+
+    override def toTextCapturing(parent: Type, refs: GeneralCaptureSet, boxText: Text) = refs match
+      case refs: CaptureSet
+      if isUniversalCaptureSet(refs) && !defn.isFunctionType(parent) && !printDebug =>
+        boxText ~ toTextLocal(parent) ~ seen.record("^", isType = true, refs.elems.nth(0))
+      case _ =>
+        super.toTextCapturing(parent, refs, boxText)
+
+    override def funMiddleText(isContextual: Boolean, isPure: Boolean, refs: GeneralCaptureSet | Null): Text =
+      refs match
+        case refs: CaptureSet if isUniversalCaptureSet(refs) =>
+          seen.record(arrow(isContextual, isPure = false), isType = true, refs.elems.nth(0))
+        case _ =>
+          super.funMiddleText(isContextual, isPure, refs)
+
     override def toTextMethodAsFunction(info: Type, isPure: Boolean, refs: GeneralCaptureSet): Text =
       info match
         case info: LambdaType =>

tests/neg-custom-args/captures/boundschecks3.check

@@ -3,22 +3,30 @@
   |           ^
   |    Type argument box test.Tree^ does not conform to upper bound test.Tree in inferred type test.C[box test.Tree^]
   |
+  |    where:    ^ refers to the universal root capability
+  |
   | longer explanation available when compiling with `-explain`
 -- [E057] Type Mismatch Error: tests/neg-custom-args/captures/boundschecks3.scala:10:11 --------------------------------
 10 |  type T = C[Tree^] // error
    |           ^
    |  Type argument box test.Tree^ does not conform to upper bound test.Tree in inferred type test.C[box test.Tree^]
    |
+   |  where:    ^ refers to the universal root capability
+   |
    | longer explanation available when compiling with `-explain`
 -- [E057] Type Mismatch Error: tests/neg-custom-args/captures/boundschecks3.scala:11:11 --------------------------------
 11 |  val bar: T -> T = ??? // error
    |           ^
    |Type argument box test.Tree^ does not conform to upper bound test.Tree in subpart test.C[box test.Tree^] of inferred type test.C[box test.Tree^] -> test.C[box test.Tree^]
    |
+   |where:    ^ refers to the universal root capability
+   |
    | longer explanation available when compiling with `-explain`
 -- [E057] Type Mismatch Error: tests/neg-custom-args/captures/boundschecks3.scala:12:11 --------------------------------
 12 |  val baz: C[Tree^] -> Unit = ??? // error
    |           ^
    |Type argument box test.Tree^ does not conform to upper bound test.Tree in subpart test.C[box test.Tree^] of inferred type test.C[box test.Tree^] -> Unit
    |
+   |where:    ^ refers to the universal root capability
+   |
    | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/box-adapt-cases.check

@@ -2,7 +2,11 @@
 8 |  x.value(cap => cap.use())  // error, was OK
   |          ^^^^^^^^^^^^^^^^
   |          Found:    (cap: box Cap^?) => Int
-  |          Required: (cap: box Cap^) ->{fresh} Int
+  |          Required: (cap: box Cap^) =>² Int
+  |
+  |          where:    =>  refers to the universal root capability
+  |                    =>² refers to a fresh root capability created in method test1
+  |                    ^   refers to the universal root capability
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/box-adapt-cases.scala:15:10 ------------------------------

tests/neg-custom-args/captures/box-adapt-contra.check

@@ -8,6 +8,9 @@
    |                                         ^^^^^^^^^^^^^^^^^^^
    |        Cap^{c} => Unit cannot be box-converted to box Cap^{c} ->{cap, c} Unit
    |        since the additional capture set {c} resulting from box conversion is not allowed in box Cap^{c} => Unit
+   |
+   |        where:    =>  refers to the universal root capability
+   |                  cap is the universal root capability
 -- Error: tests/neg-custom-args/captures/box-adapt-contra.scala:19:54 --------------------------------------------------
 19 |  val f3: (Cap^{c} -> Unit) => Unit = useCap3[Cap^{c}](c)  // error
    |                                      ^^^^^^^^^^^^^^^^^^^