Drop treatment of local roots

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -376,17 +376,6 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
     case _ =>
       tree.tpe.isInstanceOf[ThisType]
   }
-
-  /** Under capture checking, an extractor for qualified roots `cap[Q]`.
-   */
-  object QualifiedRoot:
-
-    def unapply(tree: Apply)(using Context): Option[String] = tree match
-      case Apply(fn, Literal(lit) :: Nil) if fn.symbol == defn.Caps_capIn =>
-        Some(lit.value.asInstanceOf[String])
-      case _ =>
-        None
-  end QualifiedRoot
 }
 
 trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped] =>

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

@@ -59,9 +59,6 @@ class IllegalCaptureRef(tpe: Type) extends Exception(tpe.toString)
 /** Capture checking state, which is known to other capture checking components */
 class CCState:
 
-  /** Associates nesting level owners with the local roots valid in their scopes. */
-  val localRoots: mutable.HashMap[Symbol, Symbol] = new mutable.HashMap
-
   /** The last pair of capture reference and capture set where
    *  the reference could not be added to the set due to a level conflict.
    */
@@ -80,14 +77,9 @@ class NoCommonRoot(rs: Symbol*)(using Context) extends Exception(
 extension (tree: Tree)
 
   /** Map tree with CaptureRef type to its type, throw IllegalCaptureRef otherwise */
-  def toCaptureRef(using Context): CaptureRef = tree match
-    case QualifiedRoot(outer) =>
-      ctx.owner.levelOwnerNamed(outer)
-        .orElse(defn.RootClass) // non-existing outer roots are reported in Setup's checkQualifiedRoots
-        .localRoot.termRef
-    case _ => tree.tpe match
-      case ref: CaptureRef => ref
-      case tpe => throw IllegalCaptureRef(tpe) // if this was compiled from cc syntax, problem should have been reported at Typer
+  def toCaptureRef(using Context): CaptureRef = tree.tpe match
+    case ref: CaptureRef => ref
+    case tpe => throw IllegalCaptureRef(tpe) // if this was compiled from cc syntax, problem should have been reported at Typer
 
   /** Convert a @retains or @retainsByName annotation tree to the capture set it represents.
    *  For efficience, the result is cached as an Attachment on the tree.
@@ -337,24 +329,13 @@ extension (sym: Symbol)
     && sym != defn.Caps_unsafeBox
     && sym != defn.Caps_unsafeUnbox
 
-  /** Can this symbol possibly own a local root?
-   *  TODO: Disallow anonymous functions?
+  /** Does this symbol define a level where we do not want to let local variables
+   *  escape into outer capture sets?
    */
   def isLevelOwner(using Context): Boolean =
     sym.isClass
     || sym.is(Method, butNot = Accessor)
 
-  /** The level owner enclosing `sym` which has the given name, or NoSymbol
-   *  if none exists.
-   */
-  def levelOwnerNamed(name: String)(using Context): Symbol =
-    def recur(sym: Symbol): Symbol =
-      if sym.name.toString == name then
-        if sym.isLevelOwner then sym else NoSymbol
-      else if sym == defn.RootClass then NoSymbol
-      else recur(sym.owner)
-    recur(sym)
-
   /** The owner of the current level. Qualifying owners are
    *   - methods other than constructors and anonymous functions
    *   - anonymous functions, provided they either define a local
@@ -369,14 +350,6 @@ extension (sym: Symbol)
       else recur(sym.owner)
     recur(sym)
 
-  /** The local root corresponding to sym's level owner */
-  def localRoot(using Context): Symbol =
-    val owner = sym.levelOwner
-    assert(owner.exists)
-    def newRoot = newSymbol(if owner.isClass then newLocalDummy(owner) else owner,
-      nme.LOCAL_CAPTURE_ROOT, Synthetic, defn.Caps_Cap.typeRef)
-    ccState.localRoots.getOrElseUpdate(owner, newRoot)
-
   /** The outermost symbol owned by both `sym` and `other`. if none exists
    *  since the owning scopes of `sym` and `other` are not nested, invoke
    *  `onConflict` to return a symbol.

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

@@ -77,19 +77,8 @@ sealed abstract class CaptureSet extends Showable:
 
   /** Does this capture set contain the root reference `cap` as element? */
   final def isUniversal(using Context) =
-    elems.exists(_.isUniversalRootCapability)
-
-  /** Does this capture set contain the root reference `cap` as element? */
-  final def containsRoot(using Context) =
     elems.exists(_.isRootCapability)
 
-  /** Does this capture set disallow an addiiton of `cap`, whereas it
-   *  might allow an addition of a local root?
-   */
-  final def disallowsUniversal(using Context) =
-    if isConst then !isUniversal && elems.exists(_.isLocalRootCapability)
-    else asVar.noUniversal
-
   /** Try to include an element in this capture set.
    *  @param elem    The element to be added
    *  @param origin  The set that originated the request, or `empty` if the request came from outside.
@@ -154,16 +143,15 @@ sealed abstract class CaptureSet extends Showable:
     cs.addDependent(this)(using ctx, UnrecordedState)
     this
 
-  extension (x: CaptureRef)(using Context)
-
-    /** x subsumes x
-    *   this subsumes this.f
-    *   x subsumes y  ==>  x* subsumes y
-    *   x subsumes y  ==>  x* subsumes y*
-    */
-    private def subsumes(y: CaptureRef): Boolean =
+  /** x subsumes x
+   *   this subsumes this.f
+   *   x subsumes y  ==>  x* subsumes y
+   *   x subsumes y  ==>  x* subsumes y*
+   */
+  extension (x: CaptureRef)
+     private def subsumes(y: CaptureRef)(using Context): Boolean =
       (x eq y)
-      || x.isSuperRootOf(y)
+      || x.isRootCapability
       || y.match
           case y: TermRef => !y.isReach && (y.prefix eq x)
           case _ => false
@@ -175,26 +163,6 @@ sealed abstract class CaptureSet extends Showable:
           case _ =>
             false
 
-    /** x <:< cap,   cap[x] <:< cap
-     *  cap[y] <:< cap[x] if y encloses x
-     *  y <:< cap[x] if y's level owner encloses x's local root owner
-     */
-    private def isSuperRootOf(y: CaptureRef): Boolean = x match
-      case x: TermRef =>
-        x.isUniversalRootCapability
-        || x.isLocalRootCapability && !y.isUniversalRootCapability && {
-          val xowner = x.localRootOwner
-          y match
-            case y: TermRef =>
-              xowner.isContainedIn(y.symbol.levelOwner)
-            case y: ThisType =>
-              xowner.isContainedIn(y.cls)
-            case _ =>
-              false
-        }
-      case _ => false
-  end extension
-
   /** {x} <:< this   where <:< is subcapturing, but treating all variables
    *                 as frozen.
    */
@@ -217,7 +185,7 @@ sealed abstract class CaptureSet extends Showable:
    */
   def mightAccountFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this mightAccountFor $x, ${x.captureSetOfInfo}?", show = true) {
-      elems.exists(elem => elem.subsumes(x) || elem.isRootCapability)
+      elems.exists(_.subsumes(x))
       || !x.isRootCapability
         && {
           val elems = x.captureSetOfInfo.elems
@@ -523,7 +491,7 @@ object CaptureSet:
       else
         //if id == 34 then assert(!elem.isUniversalRootCapability)
         elems += elem
-        if elem.isUniversalRootCapability then
+        if elem.isRootCapability then
           rootAddedHandler()
         newElemAddedHandler(elem)
         // assert(id != 5 || elems.size != 3, this)
@@ -534,7 +502,7 @@ object CaptureSet:
           res.addToTrace(this)
 
     private def levelOK(elem: CaptureRef)(using Context): Boolean =
-      if elem.isUniversalRootCapability then !noUniversal
+      if elem.isRootCapability then !noUniversal
       else elem match
         case elem: TermRef =>
           if elem.isReach then levelOK(elem.reachPrefix)
@@ -575,10 +543,9 @@ object CaptureSet:
      *  of this set. The universal set {cap} is a sound fallback.
      */
     final def upperApprox(origin: CaptureSet)(using Context): CaptureSet =
-      if isConst then this
-      else if elems.exists(_.isRootCapability) then
-        CaptureSet(elems.filter(_.isRootCapability).toList*)
-      else if computingApprox then
+      if isConst then
+        this
+      else if elems.exists(_.isRootCapability) || computingApprox then
         universal
       else
         computingApprox = true
@@ -1135,7 +1102,7 @@ object CaptureSet:
     override def toAdd(using Context) =
       for CompareResult.LevelError(cs, ref) <- ccState.levelError.toList yield
         ccState.levelError = None
-        if ref.isUniversalRootCapability then
+        if ref.isRootCapability then
           i"""
             |
             |Note that the universal capability `cap`

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

@@ -130,15 +130,12 @@ object CheckCaptures:
         report.error(em"Singleton type $parent cannot have capture set", parent.srcPos)
       case _ =>
     for elem <- ann.retainedElems do
-      elem match
-        case QualifiedRoot(outer) =>
-          // Will be checked by Setup's checkOuterRoots
-        case _ => elem.tpe match
-          case ref: CaptureRef =>
-            if !ref.isTrackableRef then
-              report.error(em"$elem cannot be tracked since it is not a parameter or local value", elem.srcPos)
-          case tpe =>
-            report.error(em"$elem: $tpe is not a legal element of a capture set", elem.srcPos)
+      elem.tpe match
+        case ref: CaptureRef =>
+          if !ref.isTrackableRef then
+            report.error(em"$elem cannot be tracked since it is not a parameter or local value", elem.srcPos)
+        case tpe =>
+          report.error(em"$elem: $tpe is not a legal element of a capture set", elem.srcPos)
 
   /** Report an error if some part of `tp` contains the root capability in its capture set
    *  or if it refers to an unsealed type parameter that could possibly be instantiated with
@@ -837,13 +834,9 @@ class CheckCaptures extends Recheck, SymTransformer:
           }
           checkNotUniversal(parent)
         case _ =>
-      val adapted =
-        if ccConfig.allowUniversalInBoxed then
-          adaptUniversal(tpe, pt, tree)
-        else
-          if needsUniversalCheck then checkNotUniversal(tpe)
-          tpe
-      super.recheckFinish(adapted, tree, pt)
+      if !ccConfig.allowUniversalInBoxed && needsUniversalCheck then
+        checkNotUniversal(tpe)
+      super.recheckFinish(tpe, tree, pt)
     end recheckFinish
 
     // ------------------ Adaptation -------------------------------------
@@ -855,56 +848,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     //   - Relax expected capture set containing `this.type`s by adding references only
     //     accessible through those types (c.f. addOuterRefs, also #14930 for a discussion).
     //   - Adapt box status and environment capture sets by simulating box/unbox operations.
-    //   - Instantiate `cap` in actual as needed to a local root.
-
-    /** The local root that is implied for the expression `tree`.
-     *  This is the local root of the outermost level owner that includes
-     *  all free variables of the expression that have in their types
-     *  some capturing type occuring in covariant or invariant position.
-     */
-    def impliedRoot(tree: Tree)(using Context) =
-      def isTrackedSomewhere(sym: Symbol): Boolean =
-        val search = new TypeAccumulator[Boolean]:
-          def apply(found: Boolean, tp: Type) =
-            def isTrackedHere = variance >= 0 && !tp.captureSet.isAlwaysEmpty
-            found || isTrackedHere || foldOver(found, tp)
-        if sym.is(Method)
-        then !capturedVars(sym).elems.isEmpty || search(false, sym.info.finalResultType)
-        else search(false, sym.info)
-
-      val acc = new TreeAccumulator[Symbol]:
-        val locals = mutable.Set[Symbol]()
-        private def max(sym1: Symbol, sym2: Symbol)(using Context) =
-          sym1.maxNested(sym2, onConflict = (_, _) => throw NoCommonRoot(sym1, sym2))
-        def apply(s: Symbol, t: Tree)(using Context) = t match
-          case t: (Ident | This)
-          if !locals.contains(t.symbol) && isTrackedSomewhere(t.symbol) =>
-            max(s, t.symbol.levelOwner)
-          case t: DefTree =>
-            locals += t.symbol
-            foldOver(s, t)
-          case _ =>
-            foldOver(s, t)
-      acc(NoSymbol, tree).orElse(ctx.owner).localRoot
-
-    /** Assume `actual` is the type of an expression `tree` with the given
-     *  `expected` type. If `actual` captures `cap` and `cap` is not allowed
-     *  in the capture set of `expected`, narrow `cap` to the root capability
-     *  that is implied for `tree`.
-     */
-    def adaptUniversal(actual: Type, expected: Type, tree: Tree)(using Context): Type =
-      if expected.captureSet.disallowsUniversal && actual.captureSet.isUniversal then
-        if actual.isInstanceOf[SingletonType] then
-          // capture set is only exposed when widening
-          adaptUniversal(actual.widen, expected, tree)
-        else
-          val localRoot = impliedRoot(tree)
-          CapturingType(
-              actual.stripCapturing,
-              localRoot.termRef.singletonCaptureSet,
-              actual.isBoxedCapturing)
-            .showing(i"adapt universal $actual vs $expected = $result", capt)
-      else actual
+    //   - Instantiate covariant occurrenves of `cap` in actual to reach capabilities.
 
     private inline val debugSuccesses = false
 
@@ -1369,20 +1313,6 @@ class CheckCaptures extends Recheck, SymTransformer:
         checker.traverse(tree.knownType)
     end healTypeParam
 
-    def checkNoLocalRootIn(sym: Symbol, info: Type, pos: SrcPos)(using Context): Unit =
-      val check = new TypeTraverser:
-        def traverse(tp: Type) = tp match
-          case tp: TermRef if tp.isLocalRootCapability =>
-            if tp.localRootOwner == sym then
-              report.error(i"local root $tp cannot appear in type of $sym", pos)
-          case tp: ClassInfo =>
-            traverseChildren(tp)
-            for mbr <- tp.decls do
-              if !mbr.is(Private) then checkNoLocalRootIn(sym, mbr.info, mbr.srcPos)
-          case _ =>
-            traverseChildren(tp)
-      check.traverse(info)
-
     def checkArraysAreSealedIn(tp: Type, pos: SrcPos)(using Context): Unit =
       val check = new TypeTraverser:
         def traverse(t: Type): Unit =
@@ -1426,8 +1356,6 @@ class CheckCaptures extends Recheck, SymTransformer:
                 checkBounds(normArgs, tl)
                 args.lazyZip(tl.paramNames).foreach(healTypeParam(_, _, fun.symbol))
               case _ =>
-          case _: ValOrDefDef | _: TypeDef =>
-            checkNoLocalRootIn(tree.symbol, tree.symbol.info, tree.symbol.srcPos)
           case tree: TypeTree =>
             checkArraysAreSealedIn(tree.tpe, tree.srcPos)
           case _ =>

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

@@ -275,23 +275,16 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         then CapturingType(tp, defn.expandedUniversalSet, boxed = false)
         else tp
 
-      private def checkQualifiedRoots(tree: Tree): Unit =
-        for case elem @ QualifiedRoot(outer) <- tree.retainedElems do
-          if !ctx.owner.levelOwnerNamed(outer).exists then
-            report.error(em"`$outer` does not name an outer definition that represents a capture level", elem.srcPos)
-
       private def recur(t: Type): Type = normalizeCaptures(mapOver(t))
 
       def apply(t: Type) =
         t match
           case t @ CapturingType(parent, refs) =>
-            checkQualifiedRoots(t.annot.tree) // TODO: NEEDED?
             t.derivedCapturingType(this(parent), refs)
           case t @ AnnotatedType(parent, ann) =>
             val parent1 = this(parent)
             if ann.symbol == defn.RetainsAnnot then
               for tpt <- tptToCheck do
-                checkQualifiedRoots(ann.tree)
                 checkWellformedLater(parent1, ann.tree, tpt)
               CapturingType(parent1, ann.tree.toCaptureSet)
             else
@@ -588,11 +581,11 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       case CapturingType(parent, refs) =>
         needsVariable(parent)
         && refs.isConst       // if refs is a variable, no need to add another
-        && !refs.containsRoot // if refs is {cap}, an added variable would not change anything
+        && !refs.isUniversal  // if refs is {cap}, an added variable would not change anything
       case RetainingType(parent, refs) =>
         needsVariable(parent)
         && !refs.tpes.exists:
-            case ref: TermRef => ref.isUniversalRootCapability
+            case ref: TermRef => ref.isRootCapability
             case _ => false
       case AnnotatedType(parent, _) =>
         needsVariable(parent)

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

@@ -988,7 +988,6 @@ class Definitions {
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
     @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("cap")
     @tu lazy val Caps_Cap: TypeSymbol = CapsModule.requiredType("Cap")
-    @tu lazy val Caps_capIn: TermSymbol = CapsModule.requiredMethod("capIn")
     @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
     @tu lazy val Caps_unsafeAssumePure: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumePure")
     @tu lazy val Caps_unsafeBox: Symbol = CapsUnsafeModule.requiredMethod("unsafeBox")

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

@@ -288,7 +288,6 @@ object StdNames {
 
     // Compiler-internal
     val CAPTURE_ROOT: N             = "cap"
-    val LOCAL_CAPTURE_ROOT: N       = "<local-cap>"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
     val EVT2U: N                    = "evt2u$"