Drop CaptureRoot and AddTryOwners

Author: odersky

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

@@ -61,9 +61,6 @@ class IllegalCaptureRef(tpe: Type) extends Exception(tpe.toString)
 /** Capture checking state, which is known to other capture checking components */
 class CCState:
 
-  /** Cache for level ownership */
-  val isLevelOwner: mutable.HashMap[Symbol, Boolean] = new mutable.HashMap
-
   /** Associates nesting level owners with the local roots valid in their scopes. */
   val localRoots: mutable.HashMap[Symbol, Symbol] = new mutable.HashMap
 
@@ -72,11 +69,6 @@ class CCState:
    */
   var levelError: Option[CaptureSet.CompareResult.LevelError] = None
 
-  /** Under saferExceptions: The <try block> symbol generated  for a try.
-   *  Installed by Setup, removed by CheckCaptures.
-   */
-  val tryBlockOwner: mutable.HashMap[Try, Symbol] = new mutable.HashMap
-
 end CCState
 
 /** The currently valid CCState */

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

@@ -536,8 +536,6 @@ object CaptureSet:
             levelLimit.isContainedIn(sym.levelOwner)
           case elem: ThisType =>
             levelLimit.isContainedIn(elem.cls.levelOwner)
-          case elem: CaptureRoot.Var =>
-            elem.encloses(levelLimit.localRoot.termRef)
           case _ => true
 
     def addDependent(cs: CaptureSet)(using Context, VarState): CompareResult =

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

@@ -195,7 +195,7 @@ class CheckCaptures extends Recheck, SymTransformer:
   def phaseName: String = "cc"
 
   override def isRunnable(using Context) = super.isRunnable && Feature.ccEnabledSomewhere
-  override def firstPrepPhase = preRecheckPhase.prev.asInstanceOf[AddTryOwners]
+  override def firstPrepPhase = preRecheckPhase
 
   def newRechecker()(using Context) = CaptureChecker(ctx)
 
@@ -221,14 +221,6 @@ class CheckCaptures extends Recheck, SymTransformer:
           refs match
             case refs: CaptureSet.Var if variance < 0 => refs.solve()
             case _ =>
-          for ref <- refs.elems do
-            ref match
-              case ref: CaptureRoot.Var =>
-                ref.followAlias match
-                  case rv: CaptureRoot.Var if rv.innerLimit == ctx.owner.levelOwner =>
-                    rv.alias = ctx.owner.localRoot.termRef
-                  case _ =>
-              case _ =>
           traverse(parent)
         case t @ defn.RefinedFunctionOf(rinfo) =>
           traverse(rinfo)
@@ -683,14 +675,13 @@ class CheckCaptures extends Recheck, SymTransformer:
       super.recheckTyped(tree)
 
     override def recheckTry(tree: Try, pt: Type)(using Context): Type =
-      val tryOwner = ccState.tryBlockOwner.remove(tree).getOrElse(ctx.owner)
+/*
       val saved = curEnv
       curEnv = Env(tryOwner, EnvKind.Regular, CaptureSet.Var(curEnv.owner), curEnv)
-      val tp = try
-        inContext(ctx.withOwner(tryOwner)):
-          super.recheckTry(tree, pt)
-        finally
-          curEnv = saved
+      val tp =
+        try super.recheckTry(tree, pt)
+        finally curEnv = saved*/
+      val tp = super.recheckTry(tree, pt)
       if allowUniversalInBoxed && Feature.enabled(Feature.saferExceptions) then
         disallowRootCapabilitiesIn(tp, ctx.owner,
           "result of `try`", "have type",

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

@@ -36,7 +36,7 @@ import config.Printers.{core, typr, matchTypes}
 import reporting.{trace, Message}
 import java.lang.ref.WeakReference
 import compiletime.uninitialized
-import cc.{CapturingType, CaptureSet, derivedCapturingType, isBoxedCapturing, RetainingType, CaptureRoot, isCaptureChecking}
+import cc.{CapturingType, CaptureSet, derivedCapturingType, isBoxedCapturing, RetainingType, isCaptureChecking}
 import CaptureSet.{CompareResult, IdempotentCaptRefMap, IdentityCaptRefMap}
 
 import scala.annotation.internal.sharable
@@ -2189,7 +2189,6 @@ object Types {
      */
     def isLocalRootCapability(using Context): Boolean = this match
       case tp: TermRef => tp.localRootOwner.exists
-      case tp: CaptureRoot.Var => true
       case _ => false
 
     /** Is this reference the a (local or generic) root capability? */

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

@@ -15,7 +15,7 @@ import util.SourcePosition
 import scala.util.control.NonFatal
 import scala.annotation.switch
 import config.{Config, Feature}
-import cc.{CapturingType, RetainingType, CaptureSet, CaptureRoot, isBoxed, levelOwner, retainedElems}
+import cc.{CapturingType, RetainingType, CaptureSet, isBoxed, levelOwner, retainedElems}
 
 class PlainPrinter(_ctx: Context) extends Printer {
 
@@ -48,12 +48,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
   protected def homogenizedView: Boolean = ctx.settings.YtestPickler.value
   protected def debugPos: Boolean = ctx.settings.YdebugPos.value
 
-  /** If true, shorten local roots of current owner tp `cap`,
-   *  For now it is better to turn this off, so that we get the best info for diagnosis.
-   *  TODO: we should consider dropping this switch once we implemented disambiguation of capture roots.
-   */
-  private val shortenCap = false
-
   def homogenize(tp: Type): Type =
     if (homogenizedView)
       tp match {
@@ -253,16 +247,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
         val rootsInRefs = refs.elems.filter(isRootCap(_)).toList
         val showAsCap = rootsInRefs match
           case (tp: TermRef) :: Nil =>
-            if tp.symbol == defn.captureRoot then
-              refs.elems.size == 1 || !printDebug
-                // {caps.cap} gets printed as `{cap}` even under printDebug as long as there
-                // are no other elements in the set
-            else
-              tp.symbol.name == nme.LOCAL_CAPTURE_ROOT
-              && ctx.owner.levelOwner == tp.localRootOwner
-              && !printDebug
-              && shortenCap // !!!
-                // local roots get printed as themselves under printDebug
+            tp.symbol == defn.captureRoot && (refs.elems.size == 1 || !printDebug)
+              // {caps.cap} gets printed as `{cap}` even under printDebug as long as there
+              // are no other elements in the set
           case _ =>
             false
         val refsText = if showAsCap then rootSetText else toTextCaptureSet(refs)
@@ -405,9 +392,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     tp match {
       case tp: TermRef =>
         if tp.symbol.name == nme.LOCAL_CAPTURE_ROOT then  // TODO: Move to toTextCaptureRef
-          if ctx.owner.levelOwner == tp.localRootOwner && !printDebug && shortenCap
-          then Str("cap")
-          else Str(s"cap[${nameString(tp.localRootOwner)}]")
+          Str(s"cap[${nameString(tp.localRootOwner)}]")
         else toTextPrefixOf(tp) ~ selectionString(tp)
       case tp: ThisType =>
         nameString(tp.cls) + ".this"
@@ -427,17 +412,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
         if (homogenizedView) toText(tp.info)
         else if (ctx.settings.XprintTypes.value) "<" ~ toText(tp.repr) ~ ":" ~ toText(tp.info) ~ ">"
         else toText(tp.repr)
-      case tp: CaptureRoot.Var =>
-        if tp.followAlias ne tp then toTextRef(tp.followAlias)
-        else
-          def boundText(sym: Symbol): Text =
-            toTextRef(sym.termRef).provided(sym.exists)
-          "'cap["
-          ~ toTextRef(tp.outerLimit.termRef).provided(!tp.outerLimit.isRoot)
-          ~ ".."
-          ~ toTextRef(tp.innerLimit.termRef)
-          ~ "]"
-          ~ ("(from instantiating " ~ nameString(tp.source) ~ ")").provided(tp.source.exists)
     }
   }