Rename SharedCapability to Sharable and add Control capability class

Author: odersky

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

@@ -1290,7 +1290,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case ExistentialSubsumesFailure(ex, other) =>
               def since =
                 if other.isTerminalCapability then ""
-                else " since that capability is not a SharedCapability"
+                else " since that capability is not a `Sharable` capability"
               i"""the existential capture root in ${ex.originalBinder.resType}
                  |cannot subsume the capability $other$since"""
             case MutAdaptFailure(cs, lo, hi) =>

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

@@ -597,7 +597,7 @@ class SepCheck(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
    *   - If the reference is to a this type of the enclosing class, the
    *     access must be in a @consume method.
    *
-   *  References that extend SharedCapability are excluded from checking.
+   *  References that extend cpas.Sharable are excluded from checking.
    *  As a side effect, add all checked references with the given position `pos`
    *  to the global `consumed` map.
    *

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

@@ -375,10 +375,10 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         else fntpe
 
       /** 1. Check that parents of capturing types are not pure.
-       *  2. Check that types extending SharedCapability don't have a `cap` in their capture set.
+       *  2. Check that types extending caps.Sharable don't have a `cap` in their capture set.
        *     TODO This is not enough.
        *     We need to also track that we cannot get exclusive capabilities in paths
-       *     where some prefix derives from SharedCapability. Also, can we just
+       *     where some prefix derives from Sharable. Also, can we just
        *     exclude `cap`, or do we have to extend this to all exclusive capabilties?
        *     The problem is that we know what is exclusive in general only after capture
        *     checking, not before.

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

@@ -1011,7 +1011,7 @@ class Definitions {
     @tu lazy val Caps_ContainsModule: Symbol = requiredModule("scala.caps.Contains")
     @tu lazy val Caps_containsImpl: TermSymbol = Caps_ContainsModule.requiredMethod("containsImpl")
     @tu lazy val Caps_Mutable: ClassSymbol = requiredClass("scala.caps.Mutable")
-    @tu lazy val Caps_SharedCapability: ClassSymbol = requiredClass("scala.caps.SharedCapability")
+    @tu lazy val Caps_SharedCapability: ClassSymbol = requiredClass("scala.caps.Sharable")
 
   @tu lazy val PureClass: Symbol = requiredClass("scala.Pure")
 

library/src/scala/CanThrow.scala

@@ -8,7 +8,7 @@ import annotation.{implicitNotFound, experimental, capability}
  */
 @experimental
 @implicitNotFound("The capability to throw exception ${E} is missing.\nThe capability can be provided by one of the following:\n - Adding a using clause `(using CanThrow[${E}])` to the definition of the enclosing method\n - Adding `throws ${E}` clause after the result type of the enclosing method\n - Wrapping this piece of code with a `try` block that catches ${E}")
-erased class CanThrow[-E <: Exception] extends caps.SharedCapability
+erased class CanThrow[-E <: Exception] extends caps.Control
 
 @experimental
 object unsafeExceptions:

library/src/scala/caps/package.scala

@@ -37,7 +37,13 @@ trait Mutable extends Capability
   * During separation checking, shared capabilities are not taken into account.
   */
 @experimental
-trait SharedCapability extends Capability
+trait Sharable extends Capability
+
+/** Base trait for capabilities that capture some continuation or return point in
+ *  the stack. Examples are exceptions, labels, Async, CanThrow.
+ */
+@experimental
+trait Control extends Sharable
 
 /** Carrier trait for capture set type parameters */
 @experimental

tests/neg-custom-args/captures/capt-capability.scala

@@ -1,7 +1,7 @@
-import caps.{Capability, SharedCapability}
+import caps.{Capability, Sharable}
 
 def foo() =
-  val x: SharedCapability = ???
+  val x: Sharable = ???
 
   val z3 =
     if x == null then (y: Unit) => x else (y: Unit) => new Capability() {} // error

tests/neg-custom-args/captures/cc-existential-conformance.check

@@ -19,7 +19,7 @@
   |                             where:    ^ refers to a root capability associated with the result type of (x: A): B^
   |
   |                             Note that the existential capture root in B^
-  |                             cannot subsume the capability y* since that capability is not a SharedCapability
+  |                             cannot subsume the capability y* since that capability is not a `Sharable` capability
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/cc-existential-conformance.scala:13:19 -------------------
@@ -43,6 +43,6 @@
    |                        where:    ^ refers to a root capability associated with the result type of (x: A): B^
    |
    |                        Note that the existential capture root in B^
-   |                        cannot subsume the capability y* since that capability is not a SharedCapability
+   |                        cannot subsume the capability y* since that capability is not a `Sharable` capability
    |
    | longer explanation available when compiling with `-explain`

tests/neg-custom-args/captures/cc-poly-source.scala

@@ -30,7 +30,7 @@ import caps.use
     val listeners = lbls.map(makeListener) // error
       // we get an error here because we no longer allow contravariant cap
       // to subsume other capabilities. The problem can be solved by declaring
-      // Label a SharedCapability, see cc-poly-source-capability.scala
+      // Label a Sharable, see cc-poly-source-capability.scala
     val src = Source[{lbls*}]
     for l <- listeners do
       src.register(l)

tests/neg-custom-args/captures/effect-swaps-explicit.scala

@@ -14,7 +14,7 @@ end boundary
 
 import boundary.{Label, break}
 
-trait Async extends caps.SharedCapability
+trait Async extends caps.Sharable
 object Async:
   def blocking[T](body: Async ?=> T): T = ???