Drop user-defined local roots

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

@@ -339,24 +339,13 @@ extension (sym: Symbol)
       else recur(sym.owner)
     recur(sym)
 
-  /** The parameter with type caps.Cap in the leading term parameter section,
-   *  or NoSymbol, if none exists.
-   */
-  def definedLocalRoot(using Context): Symbol =
-    sym.paramSymss.dropWhile(psyms => psyms.nonEmpty && psyms.head.isType) match
-      case psyms :: _ => psyms.find(_.info.typeSymbol == defn.Caps_Cap).getOrElse(NoSymbol)
-      case _ => NoSymbol
-
   /** 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)
-    def lclRoot =
-      if owner.isTerm then owner.definedLocalRoot.orElse(newRoot)
-      else newRoot
-    ccState.localRoots.getOrElseUpdate(owner, lclRoot)
+    ccState.localRoots.getOrElseUpdate(owner, newRoot)
 
   def maxNested(other: Symbol, onConflict: (Symbol, Symbol) => Context ?=> Symbol)(using Context): Symbol =
     if !sym.exists || other.isContainedIn(sym) then other

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

@@ -559,7 +559,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
       case tp: (RefinedOrRecType | MatchType) =>
         superTypeIsImpure(tp.underlying)
       case tp: AndType =>
-        superTypeIsImpure(tp.tp1) || needsVariable(tp.tp2)
+        superTypeIsImpure(tp.tp1) || superTypeIsImpure(tp.tp2)
       case tp: OrType =>
         superTypeIsImpure(tp.tp1) && superTypeIsImpure(tp.tp2)
       case _ =>

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

@@ -2927,9 +2927,7 @@ object Types {
       // TODO Try to make local class roots be NonMembers owned directly by the class
       val owner = symbol.maybeOwner
       def normOwner = if owner.isLocalDummy then owner.owner else owner
-      if name == nme.LOCAL_CAPTURE_ROOT then normOwner
-      else if info.isRef(defn.Caps_Cap) && owner.isTerm then normOwner
-      else NoSymbol
+      if name == nme.LOCAL_CAPTURE_ROOT then normOwner else NoSymbol
 
     override def normalizedRef(using Context): CaptureRef =
       if isTrackableRef then symbol.termRef else this

tests/neg-custom-args/captures/usingLogFile-alt.scala → tests/neg-custom-args/captures/usingFile.scala

@@ -7,7 +7,7 @@ object Test:
   class Logger(f: OutputStream^):
     def log(msg: String): Unit = ???
 
-  def usingFile[T](name: String, op: (lcap: caps.Cap) ?-> OutputStream^{lcap} => T): T =
+  def usingFile[sealed T](name: String, op: OutputStream^ => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()

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

@@ -30,18 +30,23 @@
    |
    |                       where:    x$0  is a reference to a value parameter
    |                                 x$0² is a reference to a value parameter
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:47:14 ------------------------------------------------------
-47 |  val later = usingLogFile { f => () => f.write(0) } // error
-   |              ^^^^^^^^^^^^
-   |              escaping local reference local.type
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:62:16 ------------------------------------------------------
-62 |    val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:52:16 ------------------------------------------------------
+52 |    val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
    |                ^^^^^^^^^
-   |                escaping local reference local.type
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:70:16 ------------------------------------------------------
-70 |    val later = usingFile("logfile", // error !!! but should be ok, since we can widen `l` to `file` instead of to `cap`
+   |                reference (caps.cap : caps.Cap) is not included in the allowed capture set {x$0, x$0²}
+   |
+   |                Note that the universal capability `cap`
+   |                cannot be included in capture set {x$0, x$0}
+   |
+   |                where:    x$0  is a reference to a value parameter
+   |                          x$0² is a reference to a value parameter
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:60:16 ------------------------------------------------------
+60 |    val later = usingFile("logfile", // error !!! but should be ok, since we can widen `l` to `file` instead of to `cap`
    |                ^^^^^^^^^
-   |          reference (_$1 : java.io.OutputStream^{local}) is not included in the allowed capture set {x$0, local}
+   |                reference (_$1 : java.io.OutputStream^) is not included in the allowed capture set {x$0, x$0²}
+   |
+   |                Note that reference (_$1 : java.io.OutputStream^), defined in method $anonfun
+   |                cannot be included in outer capture set {x$0, x$0} which is associated with method test
    |
-   |          Note that reference (_$1 : java.io.OutputStream^{local}), defined in method $anonfun
-   |          cannot be included in outer capture set {x$0, local} which is associated with method test
+   |                where:    x$0  is a reference to a value parameter
+   |                          x$0² is a reference to a value parameter

tests/neg-custom-args/captures/usingLogFile.scala

@@ -37,20 +37,10 @@ object Test2:
   later4.x()
 
 object Test3:
-
-  def usingLogFile[T](op: (local: caps.Cap) ?-> FileOutputStream^{local} => T) =
-    val logFile = FileOutputStream("log")
-    val result = op(logFile)
-    logFile.close()
-    result
-
-  val later = usingLogFile { f => () => f.write(0) } // error
-
-object Test4:
   class Logger(f: OutputStream^):
     def log(msg: String): Unit = ???
 
-  def usingFile[T](name: String, op: (local: caps.Cap) ?-> OutputStream^{local} => T): T =
+  def usingFile[sealed T](name: String, op: OutputStream^ => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()
@@ -62,7 +52,7 @@ object Test4:
     val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
     later(1)
 
-  def usingLogger[T](f: OutputStream^, op: (local: caps.Cap) ?-> Logger^{f} => T): T =
+  def usingLogger[sealed T](f: OutputStream^, op: Logger^{f} => T): T =
     val logger = Logger(f)
     op(logger)