Improve printing of Fresh in parts of types

We need to keep track of the enclosing type structure with all Fresh binders
and restore it at the point where we are printing a part of a type.

Author: odersky

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

@@ -101,6 +101,8 @@ class CCState:
   private var curLevel: Level = outermostLevel
   private val symLevel: mutable.Map[Symbol, Int] = mutable.Map()
 
+  private var openedFreshBinders: List[MethodType] = Nil
+
 object CCState:
 
   opaque type Level = Int
@@ -126,6 +128,14 @@ object CCState:
     if !p then ccs.curLevel = ccs.curLevel.nextInner
     try op finally ccs.curLevel = saved
 
+  inline def inOpenedFreshBinder[T](mt: MethodType)(op: => T)(using Context): T =
+    val ccs = ccState
+    val saved = ccs.openedFreshBinders
+    if mt.isFreshBinder then ccs.openedFreshBinders = mt :: ccs.openedFreshBinders
+    try op finally ccs.openedFreshBinders = saved
+
+  def openedFreshBinders(using Context): List[MethodType] = ccState.openedFreshBinders
+
   extension (x: Level)
     def isDefined: Boolean = x >= 0
     def <= (y: Level) = (x: Int) <= y
@@ -578,6 +588,10 @@ extension (tp: Type)
       case tp: MethodOrPoly => tp.resType.hasSuffix(other)
       case _ => false
 
+  def isFreshBinder(using Context): Boolean = tp match
+    case tp: MethodType => !tp.resType.isInstanceOf[MethodOrPoly]
+    case _ => false
+
 extension (cls: ClassSymbol)
 
   def pureBaseClass(using Context): Option[Symbol] =

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

@@ -166,6 +166,7 @@ object CheckCaptures:
     val check = new TypeTraverser:
 
       private val seen = new EqHashSet[TypeRef]
+      var openFreshBinders: List[MethodType] = Nil
 
       def traverse(t: Type) =
         t.dealiasKeepAnnots match
@@ -184,13 +185,32 @@ object CheckCaptures:
             ()
           case CapturingType(parent, refs) =>
             if variance >= 0 then
+              val openBinders = openFreshBinders
               refs.disallowRootCapability: () =>
-                def part = if t eq tp then "" else i"the part $t of "
+                def part =
+                  if t eq tp then ""
+                  else
+                    // Show in context of all enclosing traversed fresh binders.
+                    def showInOpenedFreshBinders(mts: List[MethodType]): String = mts match
+                      case Nil => i"the part $t of "
+                      case mt :: mts1 =>
+                        CCState.inOpenedFreshBinder(mt):
+                          showInOpenedFreshBinders(mts1)
+                    showInOpenedFreshBinders(openBinders.reverse)
                 report.error(
                   em"""$what cannot $have $tp since
                       |${part}that type captures the root capability `cap`.$addendum""",
                   pos)
             traverse(parent)
+          case defn.RefinedFunctionOf(mt) =>
+            traverse(mt)
+          case t: MethodType if t.isFreshBinder =>
+            atVariance(-variance):
+              t.paramInfos.foreach(traverse)
+            val saved = openFreshBinders
+            openFreshBinders = t :: openFreshBinders
+            try traverse(t.resType)
+            finally openFreshBinders = saved
           case t =>
             traverseChildren(t)
     if ccConfig.useSealed then check.traverse(tp)

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

@@ -311,7 +311,7 @@ object Existential:
         case t: MethodType =>
           // skip parameters
           val saved = localBinders
-          if !t.resType.isInstanceOf[MethodOrPoly] && !deep then localBinders = localBinders + t
+          if t.isFreshBinder && !deep then localBinders = localBinders + t
           try t.derivedLambdaType(resType = this(t.resType))
           finally localBinders = saved
         case t: PolyType =>
@@ -484,7 +484,7 @@ object Existential:
         val mt1 = apply(mt)
         if mt1 ne mt then mt1.toFunctionType(alwaysDependent = true)
         else t
-      case t: MethodType if variance > 0 && !t.resType.isInstanceOf[MethodOrPoly] =>
+      case t: MethodType if variance > 0 && t.isFreshBinder =>
         val t1 = mapOver(t).asInstanceOf[MethodType]
         t1.derivedLambdaType(resType =
           if ccConfig.newScheme then mapCap(t1.resType, t1, fail)

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

@@ -823,7 +823,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             (tp1.signature consistentParams tp2.signature) &&
             matchingMethodParams(tp1, tp2) &&
             (!tp2.isImplicitMethod || tp1.isImplicitMethod) &&
-            inOpenedMethod(tp2):
+            CCState.inOpenedFreshBinder(tp2):
               isSubType(tp1.resultType, tp2.resultType.subst(tp2, tp1))
           case _ => false
         }
@@ -2829,11 +2829,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     finally
       assocExistentialsOLD = saved
 
-  private def inOpenedMethod[T](mt: MethodType)(op: => T)(using Context): T =
-    val saved = openedMethods
-    if !mt.resType.isInstanceOf[MethodOrPoly] then openedMethods = mt :: openedMethods
-    try op finally openedMethods = saved
-
   /** Is `tp1` an existential var that subsumes `tp2`? This is the case if `tp1` is
    *  instantiatable (i.e. it's a key in `assocExistentials`) and one of the
    *  following is true:
@@ -2865,7 +2860,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
 
   def isOpenedExistential(ref: CaptureRef)(using Context): Boolean =
     ref match
-      case Existential.Vble(mt) => openedMethods.contains(mt)
+      case Existential.Vble(mt) => CCState.openedFreshBinders.contains(mt)
       case _ => openedExistentialsOLD.contains(ref)
 
   /** bi-map taking existentials to the left of a comparison to matching

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

@@ -48,14 +48,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
     limiter.register(str)
     Texts.Str(str, lineRange)
 
-  private var openMethods: List[MethodOrPoly] = Nil
-
-  protected def inOpenMethod[T](mt: MethodOrPoly | Null)(op: => T)(using Context): T =
-    val saved = openMethods
-    if mt != null && !mt.resType.isInstanceOf[MethodOrPoly] then
-      openMethods = mt :: openMethods
-    try op finally openMethods = saved
-
   given stringToText: Conversion[String, Text] = Str(_)
 
   /** If true, tweak output so it is the same before and after pickling */
@@ -270,7 +262,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
             && (refs.isUniversal
                 || refs.elems.nth(0).match
                       case Existential.Vble(binder) =>
-                        openMethods.nonEmpty && openMethods.head == binder
+                        CCState.openedFreshBinders match
+                          case b :: _ => binder eq b
+                          case _ => false
                       case _ =>
                         false
             )
@@ -307,7 +301,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           ~ paramsText(tp)
           ~ ")"
           ~ (Str(": ") provided !tp.resultType.isInstanceOf[MethodOrPoly])
-          ~ inOpenMethod(tp)(toText(tp.resultType))
+          ~ CCState.inOpenedFreshBinder(tp)(toText(tp.resultType))
         }
       case ExprType(restp) =>
         def arrowText: Text = restp match
@@ -463,7 +457,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case Existential.VarOLD(bv) => toTextRef(bv)
       case Existential.Vble(binder) =>
         // TODO: Better printing? USe a mode where we print more detailed
-        val vbleText: Text = openMethods.indexOf(binder) match
+        val vbleText: Text = CCState.openedFreshBinders.indexOf(binder) match
           case -1 =>
             "<cap of " ~ toText(binder) ~ ">"
           case n => "outer_" * n ++ "cap"

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

@@ -181,7 +181,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       argStr ~ " " ~ arrow(isContextual, isPure) ~ refs ~ " " ~ argText(res)
 
   protected def toTextMethodAsFunction(info: Type, isPure: Boolean, refs: Text = Str("")): Text =
-    def recur(tp: Type, enclInfo: MethodOrPoly | Null): Text = tp match
+    def recur(tp: Type, enclInfo: MethodType | Null): Text = tp match
       case tp: MethodType =>
         val isContextual = tp.isImplicitMethod
         val capturesRoot = refs == rootSetText
@@ -190,7 +190,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             && !showUniqueIds && !printDebug
         then
           // cc.Setup converts all functions to dependent functions. Undo that when printing.
-          inOpenMethod(tp):
+          CCState.inOpenedFreshBinder(tp):
             toTextFunction(tp.paramInfos, tp.resType, refs.provided(!capturesRoot), isContextual, isPure && !capturesRoot)
         else
           changePrec(GlobalPrec):
@@ -206,11 +206,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           "["
           ~ paramsText(tp)
           ~ "] => "
-          ~ recur(tp.resultType, tp)
+          ~ recur(tp.resultType, enclInfo)
         }
       case _ =>
-        inOpenMethod(enclInfo):
-          toText(tp)
+        if enclInfo != null then CCState.inOpenedFreshBinder(enclInfo)(toText(tp))
+        else toText(tp)
     recur(info, null)
 
   override def toText(tp: Type): Text = controlled {

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

@@ -37,7 +37,7 @@
 36 |  val z2 = h[() -> Cap](() => x) // error // error
    |             ^^^^^^^^^
    |             Type variable X of method h cannot be instantiated to () -> box C^ since
-   |             the part box C^{<cap of (): box C^>} of that type captures the root capability `cap`.
+   |             the part box C^ of that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/capt1.scala:36:30 -------------------------------------------------------------
 36 |  val z2 = h[() -> Cap](() => x) // error // error
    |                              ^
@@ -47,7 +47,7 @@
 38 |  val z3 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // error
    |             ^^^^^^^^^^^^^^^^^^^^^^^
    |             Type variable X of method h cannot be instantiated to box () ->{x} C^ since
-   |             the part C^{<cap of (): C^>} of that type captures the root capability `cap`.
+   |             the part C^ of that type captures the root capability `cap`.
 -- Error: tests/neg-custom-args/captures/capt1.scala:43:7 --------------------------------------------------------------
 43 |    if x == null then  // error: separation
    |       ^

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

@@ -21,5 +21,5 @@
 -- Error: tests/neg-custom-args/captures/i21401.scala:17:52 ------------------------------------------------------------
 17 |  val x: Boxed[IO^] = leaked[Boxed[IO^], Boxed[IO^] -> Boxed[IO^]](x => x) // error // error
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^
-   |Type variable X of value leaked cannot be instantiated to Boxed[box IO^] -> Boxed[box IO^] since
-   |the part box IO^{<cap of (x$0: Boxed[box IO^]): Boxed[box IO^]>} of that type captures the root capability `cap`.
+   |                Type variable X of value leaked cannot be instantiated to Boxed[box IO^] -> Boxed[box IO^] since
+   |                the part box IO^ of that type captures the root capability `cap`.