Changes to Mutable

 1. Mutable and ExclsuiveCapability are not longer classifiers. This means
    Mutable classes can capture other capabilities. Red is still a classifier.

 2. Update methods in nested classes can access exclsuive capabilities external
    to enclosing classes.

Author: odersky

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

@@ -573,12 +573,12 @@ class CheckCaptures extends Recheck, SymTransformer:
             // fresh capabilities. We do check that they hide no parameter reach caps in checkEscapingUses
         case _ =>
 
-      def checkReadOnlyMethod(included: CaptureSet, env: Env): Unit =
+      def checkReadOnlyMethod(included: CaptureSet, meth: Symbol): Unit =
         included.checkAddedElems: elem =>
           if elem.isExclusive then
             report.error(
-                em"""Read-only ${env.owner} accesses exclusive capability $elem;
-                    |${env.owner} should be declared an update method to allow this.""",
+                em"""Read-only $meth accesses exclusive capability $elem;
+                    |$meth should be declared an update method to allow this.""",
                 tree.srcPos)
 
       def recur(cs: CaptureSet, env: Env, lastEnv: Env | Null): Unit =

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

@@ -47,7 +47,8 @@ object Mutability:
 
   extension (sym: Symbol)
     /** An update method is either a method marked with `update` or
-     *  a setter of a non-transparent var.
+     *  a setter of a non-transparent var. `update` is implicit for `consume` methods
+     *  of Mutable classes.
      */
     def isUpdateMethod(using Context): Boolean =
       sym.isAllOf(Mutable | Method)
@@ -63,8 +64,9 @@ object Mutability:
     private def inExclusivePartOf(cls: Symbol)(using Context): Exclusivity =
       import Exclusivity.*
       if sym == cls then OK // we are directly in `cls` or in one of its constructors
+      else if sym.isUpdateMethod then OK
       else if sym.owner == cls then
-        if sym.isUpdateMethod || sym.isConstructor then OK
+        if sym.isConstructor then OK
         else NotInUpdateMethod(sym, cls)
       else if sym.isStatic then OutsideClass(cls)
       else sym.owner.inExclusivePartOf(cls)

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -995,8 +995,12 @@ class Namer { typer: Typer =>
       end if
     }
 
+    /** Add an implicit Mutable flag to consume methods in Mutable classes. This
+     *  turns the method into an update method.
+     */
     private def normalizeFlags(denot: SymDenotation)(using Context): Unit =
-      if denot.is(Method) && denot.hasAnnotation(defn.ConsumeAnnot) then
+      if denot.is(Method) && denot.hasAnnotation(defn.ConsumeAnnot)
+          && denot.owner.derivesFrom(defn.Caps_Mutable) then
         denot.setFlag(Mutable)
 
     /** Intentionally left without `using Context` parameter. We need

library/src/scala/caps/package.scala

@@ -63,7 +63,7 @@ type Shared = SharedCapability
  * During separation checking, exclusive usage of marked capabilities will be enforced.
  */
 @experimental
-trait ExclusiveCapability extends Capability, Classifier
+trait ExclusiveCapability extends Capability
 
 @experimental
 type Exclusive = ExclusiveCapability
@@ -80,7 +80,7 @@ trait Control extends SharedCapability, Classifier
 
 /** Marker trait for classes with methods that require an exclusive reference. */
 @experimental
-trait Mutable extends ExclusiveCapability, Classifier
+trait Mutable extends ExclusiveCapability
 
 /** Marker trait for classes with reader methods, typically extended by Mutable classes */
 @experimental

tests/neg-custom-args/captures/classified-inheritance.check

@@ -1,8 +1,8 @@
 -- Error: tests/neg-custom-args/captures/classified-inheritance.scala:5:6 ----------------------------------------------
-5 |class C2 extends caps.Control, caps.Mutable // error
+5 |class C2 extends caps.Control, caps.Read // error
   |      ^
-  |      class C2 inherits two unrelated classifier traits: trait Mutable and trait Control
+  |      class C2 inherits two unrelated classifier traits: trait Read and trait Control
 -- Error: tests/neg-custom-args/captures/classified-inheritance.scala:10:6 ---------------------------------------------
 10 |class C3 extends Matrix, Async // error
    |      ^
-   |      class C3 inherits two unrelated classifier traits: trait Control and trait Mutable
+   |      class C3 inherits two unrelated classifier traits: trait Control and trait Read

tests/neg-custom-args/captures/classified-inheritance.scala

@@ -2,9 +2,9 @@ import language.experimental.captureChecking
 
 class C1 extends caps.Control, caps.SharedCapability // OK
 
-class C2 extends caps.Control, caps.Mutable // error
+class C2 extends caps.Control, caps.Read // error
 
 trait Async extends caps.Control
-class Matrix extends caps.Mutable
+class Matrix extends caps.Read
 
 class C3 extends Matrix, Async // error

tests/neg-custom-args/captures/classifiers-1.scala

@@ -1,4 +1,4 @@
-class M extends caps.Mutable
+class M extends caps.Read
 
 class M1(x: Int => Int) extends M // error
 

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

@@ -14,7 +14,7 @@
    |  The two sets overlap at               : {a}
    |
    |where:    ^  refers to a fresh root capability classified as Mutable in the type of value a
-   |          ^² refers to a fresh root capability classified as Mutable created in method test1 when checking argument to parameter x of method apply
+   |          ^² refers to a fresh root capability created in method test1 when checking argument to parameter x of method apply
 -- Error: tests/neg-custom-args/captures/i23726.scala:16:5 -------------------------------------------------------------
 16 |  f3(b)  // error
    |     ^
@@ -31,7 +31,7 @@
    |  The two sets overlap at               : {b}
    |
    |where:    ^  refers to a fresh root capability classified as Mutable in the type of value b
-   |          ^² refers to a fresh root capability classified as Mutable created in method test1 when checking argument to parameter x of method apply
+   |          ^² refers to a fresh root capability created in method test1 when checking argument to parameter x of method apply
 -- Error: tests/neg-custom-args/captures/i23726.scala:24:5 -------------------------------------------------------------
 24 |  f7(a)  // error
    |     ^
@@ -48,4 +48,4 @@
    |  The two sets overlap at               : {a}
    |
    |where:    ^  refers to a fresh root capability classified as Mutable in the type of value a
-   |          ^² refers to a fresh root capability classified as Mutable created in method test1 when checking argument to parameter x of method apply
+   |          ^² refers to a fresh root capability created in method test1 when checking argument to parameter x of method apply

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

@@ -11,11 +11,12 @@ class Matrix(val f: () => Int) extends Mutable:
     update def add(): Unit = ()
 
 
-@main def test =
+def test(consume proc: () => Int) =
   val r: Ref^ = Ref()
   val m: Matrix^ = Matrix(() => 42)
   val m2: Matrix^ = Matrix(() => m.run())
   val m3: Matrix^ = Matrix(() => r.get())
+  val m4: Matrix^ = Matrix(proc)
 
   def par(f1: () => Int, f2: () => Int): Unit =
     println(s"par results: ${f1()} and ${f2()}")

tests/neg-custom-args/captures/lazyvals-sep.check

@@ -34,7 +34,7 @@
    |Note that {cap} is an exclusive capture set of the mutable type Ref^,
    |it cannot subsume a read-only capture set of the mutable type Ref^{TestClass.this.r.rd}.
    |
-   |where:    ^ and cap refer to a fresh root capability classified as Mutable created in lazy value lazyVal8 when checking argument to parameter ref of constructor Wrapper
+   |where:    ^ and cap refer to a fresh root capability created in lazy value lazyVal8 when checking argument to parameter ref of constructor Wrapper
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyvals-sep.scala:77:12 ---------------------------------
@@ -48,7 +48,7 @@
    |Note that {cap} is an exclusive capture set of the mutable type Ref^,
    |it cannot subsume a read-only capture set of the mutable type Ref^{TestClass.this.r.rd}.
    |
-   |where:    ^ and cap refer to a fresh root capability classified as Mutable created in lazy value lazyVal9 when checking argument to parameter ref of constructor Wrapper
+   |where:    ^ and cap refer to a fresh root capability created in lazy value lazyVal9 when checking argument to parameter ref of constructor Wrapper
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/lazyvals-sep.scala:82:8 -------------------------------------------------------