Two fixes to make tests pass as before

 - Avoid creating capture sets of untrackable references
 - Refine disallowRootCapability to consider only explicit captures

Author: odersky

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

@@ -1037,7 +1037,9 @@ object CaptureSet:
 
   /** The capture set of the type underlying CaptureRef */
   def ofInfo(ref: CaptureRef)(using Context): CaptureSet = ref match
-    case ref: (TermRef | TermParamRef) if ref.isMaxCapability => ref.singletonCaptureSet
+    case ref: (TermRef | TermParamRef) if ref.isMaxCapability =>
+      if ref.isTrackableRef then ref.singletonCaptureSet
+      else CaptureSet.universal
     case ReachCapability(ref1) => deepCaptureSet(ref1.widen)
       .showing(i"Deep capture set of $ref: ${ref1.widen} = $result", capt)
     case _ => ofType(ref.underlying, followResult = true)

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

@@ -157,15 +157,17 @@ object CheckCaptures:
                 case _ =>
           case AnnotatedType(_, ann) if ann.symbol == defn.UncheckedCapturesAnnot =>
             ()
-          case t =>
+          case CapturingType(parent, refs) =>
             if variance >= 0 then
-              t.captureSet.disallowRootCapability: () =>
+              refs.disallowRootCapability: () =>
                 def part = if t eq tp then "" else i"the part $t of "
                 report.error(
                   em"""$what cannot $have $tp since
                       |${part}that type captures the root capability `cap`.
                       |$addendum""",
                   pos)
+            traverse(parent)
+          case t =>
             traverseChildren(t)
     check.traverse(tp)
   end disallowRootCapabilitiesIn

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

@@ -49,6 +49,6 @@
 34 |  val z3 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // error
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |           Sealed type variable X cannot be instantiated to box () ->{x} Cap since
-   |           the part C^ of that type captures the root capability `cap`.
+   |           the part Cap of that type captures the root capability `cap`.
    |           This is often caused by a local capability in an argument of method h
    |           leaking as part of its result.

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

@@ -10,5 +10,5 @@ def useWrappedIO(wrapper: Wrapper[IO]): () -> Unit =
     wrapper: io =>
       io.brewCoffee()
 def main(): Unit =
-  val escaped = usingIO(io => useWrappedIO(mk(io))) // error // error
+  val escaped = usingIO(io => useWrappedIO(mk(io))) // error
   escaped()  // boom

tests/pos-custom-args/captures/filevar-expanded.scala

@@ -0,0 +1,36 @@
+import language.experimental.captureChecking
+import compiletime.uninitialized
+
+object test1:
+  class File:
+    def write(x: String): Unit = ???
+
+  class Service(f: File^):
+    def log = f.write("log")
+
+  def withFile[T](op: (f: File^) => T): T =
+    op(new File)
+
+  def test =
+    withFile: f =>
+      val o = Service(f)
+      o.log
+
+object test2:
+  class IO
+
+  class File:
+    def write(x: String): Unit = ???
+
+  class Service(io: IO^):
+    var file: File^{io} = uninitialized
+    def log = file.write("log")
+
+  def withFile[T](io2: IO^)(op: (f: File^{io2}) => T): T =
+    op(new File)
+
+  def test(io3: IO^) =
+    withFile(io3): f =>
+      val o = Service(io3)
+      o.file = f
+      o.log

tests/pos-custom-args/captures/filevar.scala

@@ -1,6 +1,4 @@
 import language.experimental.captureChecking
-import language.experimental.modularity
-import annotation.capability
 import compiletime.uninitialized
 
 object test1:
@@ -19,19 +17,19 @@ object test1:
       o.log
 
 object test2:
-  class IO
+  class IO extends caps.Capability
 
   class File:
     def write(x: String): Unit = ???
 
-  class Service(io: IO^):
+  class Service(io: IO):
     var file: File^{io} = uninitialized
     def log = file.write("log")
 
-  def withFile[T](io2: IO^)(op: (f: File^{io2}) => T): T =
+  def withFile[T](io2: IO)(op: (f: File^{io2}) => T): T =
     op(new File)
 
-  def test(io3: IO^) =
+  def test(io3: IO) =
     withFile(io3): f =>
       val o = Service(io3)
       o.file = f

tests/pos-custom-args/captures/logger.scala

@@ -2,12 +2,12 @@ import annotation.capability
 import language.experimental.saferExceptions
 import language.experimental.modularity
 
-class FileSystem // does not work with extends caps.Capability
+class FileSystem extends caps.Capability
 
-class Logger(using fs: FileSystem^):
+class Logger(using fs: FileSystem):
   def log(s: String): Unit = ???
 
-def test(using fs: FileSystem^) =
+def test(using fs: FileSystem) =
   val l: Logger^{fs} = Logger(using fs)
   l.log("hello world!")
   val xs: LazyList[Int]^{l} =
@@ -50,7 +50,7 @@ class Pair[+A, +B](x: A, y: B):
   def fst: A = x
   def snd: B = y
 
-def test2(ct: CanThrow[Exception], fs: FileSystem^) =
+def test2(ct: CanThrow[Exception], fs: FileSystem) =
   def x: Int ->{ct} String = ???
   def y: Logger^{fs} = ???
   def p = Pair[Int ->{ct} String, Logger^{fs}](x, y)

tests/pos-custom-args/captures/nested-classes.scala

@@ -2,21 +2,21 @@ import language.experimental.captureChecking
 import language.experimental.modularity
 import annotation.{capability, constructorOnly}
 
-class IO // does not work with extends caps.Capability
+class IO extends caps.Capability
 class Blah
-class Pkg(using io: IO^):
+class Pkg(using io: IO):
   class Foo:
     def m(foo: Blah^{io}) = ???
-class Pkg2(using io: IO^):
+class Pkg2(using io: IO):
   class Foo:
     def m(foo: Blah^{io}): Any = io; ???
 
-def main(using io: IO^) =
+def main(using io: IO) =
   val pkg = Pkg()
   val f = pkg.Foo()
-  f.m(???)
+  val x1 = f.m(???)
   val pkg2 = Pkg2()
   val f2 = pkg2.Foo()
-  f2.m(???)
+  val x2 = f2.m(???)