Also mark free identifiers referring to global symbols

Author: odersky

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

@@ -21,6 +21,7 @@ import compiletime.uninitialized
 import Capabilities.*
 import Names.Name
 import NameKinds.CapsetName
+import StdNames.nme
 
 /** A class for capture sets. Capture sets can be constants or variables.
  *  Capture sets support inclusion constraints <:< where <:< is subcapturing.
@@ -1678,6 +1679,8 @@ 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) =>
+      CaptureSet.empty
     case c: CoreCapability =>
       ofType(c.underlying, followResult = ccConfig.useSpanCapset)
 
@@ -1723,7 +1726,7 @@ object CaptureSet:
   /** The deep capture set of a type is the union of all covariant occurrences of
    *  capture sets. Nested existential sets are approximated with `cap`.
    */
-  def ofTypeDeeply(tp: Type, includeTypevars: Boolean = false, includeBoxed: Boolean = true)(using Context): CaptureSet =
+  def ofTypeDeeply(tp: Type, includeTypevars: Boolean = false, includeBoxed: Boolean = true)(using Context): CaptureSet = {
     val collect = new DeepTypeAccumulator[CaptureSet]:
 
       def capturingCase(acc: CaptureSet, parent: Type, refs: CaptureSet, boxed: Boolean) =
@@ -1736,6 +1739,15 @@ object CaptureSet:
         else this(acc, upperBound)
 
     collect(CaptureSet.empty, tp)
+  }
+
+  /** Is `ref` 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)
 
   type AssumedContains = immutable.Map[TypeRef, SimpleIdentitySet[Capability]]
   val AssumedContains: Property.Key[AssumedContains] = Property.Key()

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

@@ -732,7 +732,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           // For fields it's not a problem since `c` would already have been
           // charged for the prefix `p` in `p.x`.
           markFree(sym.info.captureSet, tree)
-        if sym.exists && !sym.isStatic then
+        if sym.exists then
           markPathFree(sym.termRef, pt, tree)
       mapResultRoots(super.recheckIdent(tree, pt), tree.symbol)
 
@@ -1269,6 +1269,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             && !(sym.is(ModuleVal) && sym.owner.is(Package))
                  // global modules that don't derive from capability can have captures
                  // only if their fields have them, and then the field was already reported.
+            && !CaptureSet.isAssumedPure(sym.termRef)
         then
           def where =
             if sym.effectiveOwner.is(Package) then "top-level definition"

tests/neg-custom-args/captures/class-caps.check

@@ -28,3 +28,15 @@
    |      value console has a non-empty capture set but will not be added as
    |      a capability to computed capture sets since it is globally accessible
    |      as a member of static object Test2. Global values cannot be capabilities.
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/class-caps.scala:37:46 -----------------------------------
+37 |  def addWritesToConsole: (Int, Int) -> Int = (a, b) => // error
+   |                                              ^
+   |                                           Found:    (a: Int, b: Int) ->{Test2.console} Int
+   |                                           Required: (Int, Int) -> Int
+   |
+   |                                           Note that capability Test2.console is not included in capture set {}.
+   |
+38 |    log(s"adding a ($a) to b ($b)")(using console)
+39 |    a + b
+   |
+   | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/class-caps.scala

@@ -34,6 +34,6 @@ object Test2:
 
   val console: Console^ = Console() // provide capability locally
 
-  def addWritesToConsole: (Int, Int) -> Int = (a, b) => // ok since `console` is static (maybe flag this?)
+  def addWritesToConsole: (Int, Int) -> Int = (a, b) => // error
     log(s"adding a ($a) to b ($b)")(using console)
     a + b