Require explicit types also for static capturing definitions

Require explicit types also for static definitions that have capture sets in their
(result-) types.

Author: odersky

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

@@ -1679,7 +1679,7 @@ object CaptureSet:
       // might happen during construction of lambdas, assume `{cap}` in this case so that
       // `ref` will not seem subsumed by other capabilities in a `++`.
       universal
-    case c: TermRef if isAssumedPure(c) =>
+    case c: TermRef if isAssumedPure(c.symbol) =>
       CaptureSet.empty
     case c: CoreCapability =>
       ofType(c.underlying, followResult = ccConfig.useSpanCapset)
@@ -1741,13 +1741,13 @@ object CaptureSet:
     collect(CaptureSet.empty, tp)
   }
 
-  /** Is `ref` assumed to be pure even though it would have a non-empty capture
+  /** Is `sym` assumed to be pure even though it would have a non-empty capture
    *  set by the normal rules?
    */
-  def isAssumedPure(ref: TermRef)(using Context): Boolean =
-    ref.name == nme.DOLLAR_VALUES     // ref is an enum $values array, which for backwards
-    && ref.symbol.owner.is(Module)    // compatible reasons is an array, but should really be an IArray.
-    && ref.symbol.owner.companionClass.is(Enum)
+  def isAssumedPure(sym: Symbol)(using Context): Boolean =
+    sym.name == nme.DOLLAR_VALUES // sym is an enum $values array, which for backwards
+    && sym.owner.is(Module)       // compatible reasons is an array, but should really be an IArray.
+    && sym.owner.companionClass.is(Enum)
 
   type AssumedContains = immutable.Map[TypeRef, SimpleIdentitySet[Capability]]
   val AssumedContains: Property.Key[AssumedContains] = Property.Key()

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

@@ -1385,8 +1385,9 @@ class CheckCaptures extends Recheck, SymTransformer:
                 // does not interfere with normal rechecking by constraining capture set variables.
             }
           // Test point (2) of doc comment above
-          if sym.owner.isClass && !sym.owner.isStaticOwner
+          if sym.owner.isClass
               && contributesFreshToClass(sym)
+              && !CaptureSet.isAssumedPure(sym)
           then
             todoAtPostCheck += { () =>
               val cls = sym.owner.asClass

tests/neg-custom-args/captures/indirect-avoid.check

@@ -27,3 +27,11 @@
    |    Note that capability nll is not included in capture set {ll}.
    |
    | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/indirect-avoid.scala:24:8 -----------------------------------------------------
+24 |  val x1 = filterImpl1(LL()) // error
+   |        ^
+   |value x1 needs an explicit type because it captures a root capability in its type Test.LL^{cap.rd}.
+   |Fields capturing a root capability need to be given an explicit type unless the capability is already
+   |subsumed by the computed capability of the enclosing class.
+   |
+   |where:    cap is a fresh root capability created in value x1 when instantiating method filterImpl1's type (ll: Test.LL^): Test.LL^{cap².rd, ll}

tests/neg-custom-args/captures/indirect-avoid.scala

@@ -21,7 +21,7 @@ object Test:
     val nll: LL^{cl} = ???
     nll
 
-  val x1 = filterImpl1(LL())
+  val x1 = filterImpl1(LL()) // error
   val _: LL^{cap.rd}= x1
   val _: LL = x1 // error
 

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

@@ -0,0 +1,64 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/withFile.scala:14:38 -------------------------------------
+14 |  private val later1 = usingLogFile { f => () => f.write() } // error
+   |                                      ^^^^^^^^^^^^^^^^^^^^
+   |Capability f outlives its scope: it leaks into outer capture set 's1 which is owned by value later1.
+   |The leakage occurred when trying to match the following types:
+   |
+   |Found:    (f: Test2.File^'s2) ->'s3 () ->{f} Unit
+   |Required: Test2.File^ => () ->'s1 Unit
+   |
+   |where:    => refers to a fresh root capability created in value later1 when checking argument to parameter op of method usingLogFile
+   |          ^  refers to the universal root capability
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/withFile.scala:15:38 -------------------------------------
+15 |  private val later2 = usingLogFile { f => Box(f) } // error
+   |                                      ^^^^^^^^^^^
+   |Capability cap outlives its scope: it leaks into outer capture set 's4 which is owned by value later2.
+   |The leakage occurred when trying to match the following types:
+   |
+   |Found:    (f: Test2.File^'s5) ->'s6 Test2.Box[Test2.File^'s7]^'s8
+   |Required: Test2.File^ => Test2.Box[Test2.File^'s4]^'s9
+   |
+   |where:    =>  refers to a fresh root capability created in value later2 when checking argument to parameter op of method usingLogFile
+   |          ^   refers to the universal root capability
+   |          cap is a root capability associated with the result type of (f: Test2.File^): Test2.Box[Test2.File^'s4]^'s9
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/withFile.scala:17:4 --------------------------------------
+17 |    f => () => f.write() // error
+   |    ^^^^^^^^^^^^^^^^^^^^
+   |Found:    (f: Test2.File^'s10) ->'s11 () ->{f} Unit
+   |Required: Test2.File^ => () =>² Unit
+   |
+   |Note that capability f is not included in capture set {cap}
+   |because (f : Test2.File^'s10) is not visible from cap in value later3.
+   |
+   |where:    =>          refers to a fresh root capability created in value later3 when checking argument to parameter op of method usingLogFile
+   |          =>² and cap refer to a fresh root capability created in value later3
+   |          ^           refers to the universal root capability
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/withFile.scala:19:4 --------------------------------------
+19 |    f => Box(f) // error
+   |    ^^^^^^^^^^^
+   |Found:    (f: Test2.File^'s12) ->'s13 Test2.Box[Test2.File^'s14]^'s15
+   |Required: Test2.File^ => Test2.Box[Test2.File^²]
+   |
+   |Note that capability cap is not included in capture set {cap²}
+   |because cap is not visible from cap² in value later4.
+   |
+   |where:    =>          refers to a fresh root capability created in value later4 when checking argument to parameter op of method usingLogFile
+   |          ^           refers to the universal root capability
+   |          ^² and cap² refer to a fresh root capability created in value later4
+   |          cap         is a root capability associated with the result type of (f: Test2.File^'s12): Test2.Box[Test2.File^'s14]^'s15
+   |
+   | longer explanation available when compiling with `-explain`
+-- Error: tests/neg-custom-args/captures/withFile.scala:16:20 ----------------------------------------------------------
+16 |  private val later3 = usingLogFile[() => Unit]: // error
+   |                    ^
+   |           value later3 needs an explicit type because it captures a root capability in its type () => Unit.
+   |           Fields capturing a root capability need to be given an explicit type unless the capability is already
+   |           subsumed by the computed capability of the enclosing class.
+   |
+   |           where:    => refers to a fresh root capability in the type of value later3

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

@@ -13,7 +13,7 @@ object Test2:
 
   private val later1 = usingLogFile { f => () => f.write() } // error
   private val later2 = usingLogFile { f => Box(f) } // error
-  private val later3 = usingLogFile[() => Unit]:
+  private val later3 = usingLogFile[() => Unit]: // error
     f => () => f.write() // error
   private val later4 = usingLogFile[Box[File^]]:
     f => Box(f) // error