Tweak cc error messages

Sometimes we have more than one representation of the same symbol, i.e.
both `^` and `cap`, or both `=>` and `cap`. If the cap is rendered first, we expand
the following string to `^{cap}` or `->{cap}` in order make it clearer that
they are the same. Unfortunately it only works if the cap comes first.

Author: odersky

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

@@ -10,6 +10,7 @@ import printing.Formatting.hl
 import config.SourceVersion
 import cc.CaptureSet
 import cc.Capabilities.*
+import util.Property
 
 import scala.annotation.threadUnsafe
 
@@ -41,6 +42,11 @@ object Message:
       i"\n$what can be rewritten automatically under -rewrite $optionStr."
     else ""
 
+  /** A context property that turns off expansion of `^` or `=>` to explicit cap's.
+   *  Used in the where clauses of error messages.
+   */
+  val NoCapExpansion = new Property.Key[Unit]
+
   /** A note can produce an added string for an error message */
   abstract class Note:
 
@@ -103,9 +109,12 @@ object Message:
      *  If the entry was not yet recorded, allocate the next superscript corresponding
      *  to the same string in the same name space. The first recording is the string proper
      *  and following recordings get consecutive superscripts starting with 2.
+     *  @param   capOk  if true and there is already a cap recorded that matches the entry,
+     *                  then use an expanded representation with explicit `cap` for the
+     *                  original string.
      *  @return  The possibly superscripted version of `str`.
      */
-    def record(str: String, isType: Boolean, entry: Recorded)(using Context): String =
+    def record(str: String, isType: Boolean, entry: Recorded, capOK: Boolean = false)(using Context): String =
       if disambi.recordOK(str) then
         //println(s"recording $str, $isType, $entry")
 
@@ -119,9 +128,6 @@ object Message:
             if (underlying.name == e1.name) underlying else e1.namedType.dealias.typeSymbol
           case _ => e1
         }
-        val key = SeenKey(str, isType)
-        val existing = seen(key)
-        lazy val dealiased = followAlias(entry)
 
         /** All lambda parameters with the same name are given the same superscript as
          *  long as their corresponding binders have the same parameter name lists.
@@ -138,13 +144,34 @@ object Message:
             case _ =>
               false
 
-        // The length of alts corresponds to the number of superscripts we need to print.
-        var alts = existing.dropWhile(alt => !sameSuperscript(dealiased, followAlias(alt)))
-        if alts.isEmpty then
-          alts = entry :: existing
-          seen(key) = alts
+        /** The superscript in `existing` that matches the current entry, using
+         *  `sameSuperscript` on dealiased entries as a test. The superscript is
+         *  the index of the matching entry in existing, counting from the right
+         *  and starting at 1. I.e last entry in the list has superscript 1, next to
+         *  last entry has superscript 2, and so on. A result of 0 means that no
+         *  matching entry exists.
+         */
+        def matchingSuperscript(existing: List[Recorded]): Int =
+          lazy val dealiased = followAlias(entry)
+          existing.dropWhile(alt => !sameSuperscript(dealiased, followAlias(alt))).length
+
+        if capOK && ctx.property(NoCapExpansion).isEmpty
+          && matchingSuperscript(seen(SeenKey("cap", isType = false))) > 0
+        then
+          val capStr = record("cap", isType = false, entry)
+          return str match
+            case "^" => s"^{$capStr}"
+            case "=>" => s"->{$capStr}"
+            case "?=>" => s"?->{$capStr}"
+
+        val key = SeenKey(str, isType)
+        val existing = seen(key)
+        var sup = matchingSuperscript(existing)
+        if sup == 0 then
+          seen(key) = entry :: existing
+          sup = existing.length + 1
 
-        val suffix = alts.length match {
+        val suffix = sup match {
           case 1 => ""
           case n => n.toString.toCharArray.map {
             case '0' => '⁰'
@@ -184,26 +211,27 @@ object Message:
           ""
       }
 
-      entry match
-        case param: TypeParamRef =>
-          s"is a type variable${addendum("constraint", TypeComparer.bounds(param))}"
-        case param: TermParamRef =>
-          s"is a reference to a value parameter"
-        case sym: Symbol =>
-          val info =
-            if (ctx.gadt.contains(sym))
-              sym.info & ctx.gadt.fullBounds(sym).nn
-            else
-              sym.info
-          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: RootCapability =>
-          val relation =
-            if keys.length > 1 then "refer to"
-            else if List("^", "=>", "?=>").exists(keys(0).startsWith) then "refers to"
-            else "is"
-          s"$relation ${ref.descr}"
+      inContext(ctx.withProperty(NoCapExpansion, Some(()))):
+        entry match
+          case param: TypeParamRef =>
+            s"is a type variable${addendum("constraint", TypeComparer.bounds(param))}"
+          case param: TermParamRef =>
+            s"is a reference to a value parameter"
+          case sym: Symbol =>
+            val info =
+              if (ctx.gadt.contains(sym))
+                sym.info & ctx.gadt.fullBounds(sym).nn
+              else
+                sym.info
+            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: RootCapability =>
+            val relation =
+              if keys.length > 1 then "refer to"
+              else if List("^", "=>", "?=>").exists(keys(0).startsWith) then "refers to"
+              else "is"
+            s"$relation ${ref.descr}"
     end explanation
 
     /** Produce a where clause with explanations for recorded iterms.
@@ -276,14 +304,14 @@ object Message:
       if isUniversalCaptureSet(refs) && !defn.isFunctionType(parent) && !printDebug && seen.isActive =>
         boxText
         ~ toTextLocal(parent)
-        ~ seen.record("^", isType = true, refs.elems.nth(0).asInstanceOf[RootCapability])
+        ~ seen.record("^", isType = true, refs.elems.nth(0).asInstanceOf[RootCapability], capOK = true)
       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.isActive =>
-          seen.record(arrow(isContextual, isPure = false), isType = true, refs.elems.nth(0).asInstanceOf[RootCapability])
+          seen.record(arrow(isContextual, isPure = false), isType = true, refs.elems.nth(0).asInstanceOf[RootCapability], capOK = true)
         case _ =>
           super.funMiddleText(isContextual, isPure, refs)
 

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

@@ -1861,12 +1861,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
      *  the singleton list consisting of its position in `args`, otherwise `Nil`.
      */
     def paramIndices(param: untpd.ValDef, args: List[untpd.Tree]): List[Int] = {
-      def loop(args: List[untpd.Tree], start: Int): List[Int] = args match {
+
+      def loop(args: List[untpd.Tree], start: Int): List[Int] = args match
         case arg :: args1 =>
           val others = loop(args1, start + 1)
           if (refersTo(arg, param)) start :: others else others
         case _ => Nil
-      }
+
       val allIndices = loop(args, 0)
       if (allIndices.length == 1) allIndices else Nil
     }

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

@@ -6,10 +6,10 @@
    |  The leakage occurred when trying to match the following types:
    |
    |  Found:    scala.util.boundary.Label[Object^'s1]
-   |  Required: scala.util.boundary.Label[Object^]^²
+   |  Required: scala.util.boundary.Label[Object^{cap}]^
    |
-   |  where:    ^ and cap refer to the universal root capability
-   |            ^²        refers to a fresh root capability classified as Control in the type of value local
+   |  where:    ^   refers to a fresh root capability classified as Control in the type of value local
+   |            cap is the universal root capability
    |
  6 |      boundary[Unit]: l2 ?=>
  7 |        boundary.break(l2)(using l1) // error

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

@@ -6,10 +6,10 @@
 -- Error: tests/neg-custom-args/captures/box-adapt-contra.scala:13:57 --------------------------------------------------
 13 |  val f1: (Cap^{c} => Unit) ->{c} Unit = useCap1[Cap^{c}](c)  // error, was ok when cap was a root
    |                                         ^^^^^^^^^^^^^^^^^^^
-   |            Cap^{c} => Unit cannot be box-converted to Cap^{c} ->{cap, c} Unit
-   |            since the additional capture set {c} resulting from box conversion is not allowed in Cap^{c} => Unit
+   |       Cap^{c} => Unit cannot be box-converted to Cap^{c} ->{cap, c} Unit
+   |       since the additional capture set {c} resulting from box conversion is not allowed in Cap^{c} ->{cap} Unit
    |
-   |            where:    => and cap refer to the universal root capability
+   |       where:    => and cap refer to 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
    |                                      ^^^^^^^^^^^^^^^^^^^

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

@@ -6,15 +6,15 @@
 22 |    val boxed1 : ((C^) => Unit) -> Unit = box1(c)  // error
    |                                          ^^^^^^^
    |C^ => Unit cannot be box-converted to C{val arg: C^²}^{c} ->{cap, c} Unit
-   |since the additional capture set {c} resulting from box conversion is not allowed in C{val arg: C^²}^{c} => Unit
+   |since the additional capture set {c} resulting from box conversion is not allowed in C{val arg: C^²}^{c} ->{cap} Unit
    |
    |where:    => and ^ and cap refer to the universal root capability
    |          ^²               refers to a fresh root capability in the type of value arg
 -- Error: tests/neg-custom-args/captures/i15772.scala:29:35 ------------------------------------------------------------
 29 |    val boxed2 : Observe[C^] = box2(c)  // error
    |                               ^^^^^^^
    |C^ => Unit cannot be box-converted to C{val arg: C^²}^{c} ->{cap, c} Unit
-   |since the additional capture set {c} resulting from box conversion is not allowed in C{val arg: C^²}^{c} => Unit
+   |since the additional capture set {c} resulting from box conversion is not allowed in C{val arg: C^²}^{c} ->{cap} Unit
    |
    |where:    => and ^ and cap refer to the universal root capability
    |          ^²               refers to a fresh root capability in the type of value arg

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

@@ -37,11 +37,11 @@
    |Capability cap outlives its scope: it leaks into outer capture set 's8 which is owned by method Test.
    |The leakage occurred when trying to match the following types:
    |
-   |Found:    (f: File^'s9, r: Ref[String]^) ->'s10 Ref[String]^
-   |Required: (f: File^, r: Ref[String]^) => Ref[String]^'s8
+   |Found:    (f: File^'s9, r: Ref[String]^{cap}) ->'s10 Ref[String]^{cap}
+   |Required: (f: File^{cap}, r: Ref[String]^{cap}) => Ref[String]^'s8
    |
-   |where:    =>        refers to a fresh root capability created in method Test when checking argument to parameter op of method withFileAndRef
-   |          ^ and cap refer to the universal root capability
+   |where:    =>  refers to a fresh root capability created in method Test when checking argument to parameter op of method withFileAndRef
+   |          cap is the universal root capability
    |
 26 |    r.put(f.read())
 27 |    r