Change root capability to cap

Author: odersky

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

@@ -70,7 +70,7 @@ sealed abstract class CaptureSet extends Showable:
     assert(!isConst)
     asInstanceOf[Var]
 
-  /** Does this capture set contain the root reference `*` as element? */
+  /** Does this capture set contain the root reference `cap` as element? */
   final def isUniversal(using Context) =
     elems.exists {
       case ref: TermRef => ref.symbol == defn.captureRoot
@@ -133,7 +133,7 @@ sealed abstract class CaptureSet extends Showable:
    *  for `x` in a state where we assume all supersets of `x` have just the elements
    *  known at this point. On the other hand if x's capture set has no known elements,
    *  a set `cs` might account for `x` only if it subsumes `x` or it contains the
-   *  root capability `*`.
+   *  root capability `cap`.
    */
   def mightAccountFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this mightAccountFor $x, ${x.captureSetOfInfo}?", show = true) {
@@ -270,7 +270,7 @@ sealed abstract class CaptureSet extends Showable:
   def substParams(tl: BindingType, to: List[Type])(using Context) =
     map(Substituters.SubstParamsMap(tl, to))
 
-  /** Invoke handler if this set has (or later aquires) the root capability `*` */
+  /** Invoke handler if this set has (or later aquires) the root capability `cap` */
   def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
     if isUniversal then handler()
     this
@@ -372,7 +372,7 @@ object CaptureSet:
     def isConst = isSolved
     def isAlwaysEmpty = false
 
-    /** A handler to be invoked if the root reference `*` is added to this set */
+    /** A handler to be invoked if the root reference `cap` is added to this set */
     var rootAddedHandler: () => Context ?=> Unit = () => ()
 
     var description: String = ""

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

@@ -433,7 +433,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case defn.FunctionOf(ptformals, _, _)
             if ptformals.nonEmpty && ptformals.forall(_.captureSet.isAlwaysEmpty) =>
               // Redo setup of the anonymous function so that formal parameters don't
-              // get capture sets. This is important to avoid false widenings to `*`
+              // get capture sets. This is important to avoid false widenings to `cap`
               // when taking the base type of the actual closures's dependent function
               // type so that it conforms to the expected non-dependent function type.
               // See withLogFile.scala for a test case.
@@ -582,7 +582,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           refs.disallowRootCapability { () =>
             val kind = if tree.isInstanceOf[ValDef] then "mutable variable" else "expression"
             report.error(
-              em"""The $kind's type $wtp is not allowed to capture the root capability `*`.
+              em"""The $kind's type $wtp is not allowed to capture the root capability `cap`.
                   |This usually means that a capability persists longer than its allowed lifetime.""",
               tree.srcPos)
           }
@@ -768,9 +768,9 @@ class CheckCaptures extends Recheck, SymTransformer:
             styp1.capturing(if alwaysConst then CaptureSet(cs1.elems) else cs1).forceBoxStatus(resultBoxed)
 
           if needsAdaptation then
-            val criticalSet =          // the set which is not allowed to have `*`
-              if covariant then cs1    // can't box with `*`
-              else expected.captureSet // can't unbox with `*`
+            val criticalSet =          // the set which is not allowed to have `cap`
+              if covariant then cs1    // can't box with `cap`
+              else expected.captureSet // can't unbox with `cap`
             if criticalSet.isUniversal && expected.isValueType then
               // We can't box/unbox the universal capability. Leave `actual` as it is
               // so we get an error in checkConforms. This tends to give better error
@@ -779,11 +779,11 @@ class CheckCaptures extends Recheck, SymTransformer:
                 println(i"cannot box/unbox $actual vs $expected")
               actual
             else
-              // Disallow future addition of `*` to `criticalSet`.
+              // Disallow future addition of `cap` to `criticalSet`.
               criticalSet.disallowRootCapability { () =>
                 report.error(
                   em"""$actual cannot be box-converted to $expected
-                      |since one of their capture sets contains the root capability `*`""",
+                      |since one of their capture sets contains the root capability `cap`""",
                 pos)
               }
               if !insertBox then  // unboxing
@@ -922,8 +922,8 @@ class CheckCaptures extends Recheck, SymTransformer:
      *    usingLogFile[box ?1 () -> Unit] { (f: {*} File) => () => { f.write(0) } }
      *
      *  We may propagate `f` into ?1, making ?1 ill-formed.
-     *  This also causes soundness issues, since `f` in ?1 should be widened to `*`,
-     *  giving rise to an error that `*` cannot be included in a boxed capture set.
+     *  This also causes soundness issues, since `f` in ?1 should be widened to `cap`,
+     *  giving rise to an error that `cap` cannot be included in a boxed capture set.
      *
      *  To solve this, we still allow ?1 to capture parameter refs like `f`, but
      *  compensate this by pushing the widened capture set of `f` into ?1.

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

@@ -967,7 +967,7 @@ class Definitions {
   @tu lazy val BreakClass: Symbol = requiredClass("scala.util.boundary.Break")
 
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
-    @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")
+    @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("cap")
     @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
     @tu lazy val Caps_unsafeBox: Symbol = CapsUnsafeModule.requiredMethod("unsafeBox")
     @tu lazy val Caps_unsafeUnbox: Symbol = CapsUnsafeModule.requiredMethod("unsafeUnbox")

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

@@ -286,8 +286,7 @@ object StdNames {
 // ----- Term names -----------------------------------------
 
     // Compiler-internal
-    val CAPTURE_ROOT: N             = "*"
-    val CAPTURE_ROOT_ALT: N         = "any"
+    val CAPTURE_ROOT: N             = "cap"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
     val EVT2U: N                    = "evt2u$"

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

@@ -2102,7 +2102,7 @@ object Types {
      */
     final def isTracked(using Context): Boolean = canBeTracked && !captureSetOfInfo.isAlwaysEmpty
 
-    /** Is this reference the root capability `*` ? */
+    /** Is this reference the root capability `cap` ? */
     def isRootCapability(using Context): Boolean = false
 
     /** Normalize reference so that it can be compared with `eq` for equality */

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -1443,7 +1443,6 @@ object Parsers {
       if in.token == THIS then simpleRef()
       else termIdent() match
         case Ident(nme.CAPTURE_ROOT) => captureRoot
-        case Ident(nme.CAPTURE_ROOT_ALT) => captureRoot
         case id => id
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
@@ -1680,7 +1679,7 @@ object Parsers {
 
     def refinedType() = refinedTypeRest(withType())
 
-    /** Disambiguation: a `^` is treated as a postfix operator meaning `^{any}`
+    /** Disambiguation: a `^` is treated as a postfix operator meaning `^{cap}`
      *  if followed by `{`, `->`, or `?->`,
      *  or followed by a new line (significant or not),
      *  or followed by a token that cannot start an infix type.

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -386,7 +386,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toTextCaptureRef(tp: Type): Text =
     homogenize(tp) match
-      case tp: TermRef if tp.symbol == defn.captureRoot => Str("*")
+      case tp: TermRef if tp.symbol == defn.captureRoot => Str("cap")
       case tp: SingletonType => toTextRef(tp)
       case _ => toText(tp)
 

library/src/scala/caps.scala

@@ -5,7 +5,8 @@ import annotation.experimental
 @experimental object caps:
 
   /** The universal capture reference */
-  val `*`: Any = ()
+  val `*`: Any = () // OLD
+  val cap: Any = () // NEW
 
   object unsafe:
 

tests/neg-custom-args/boxmap.scala

@@ -1,5 +1,5 @@
 import annotation.retains
-type Top = Any @retains(caps.*)
+type Top = Any @retains(caps.cap)
 
 type Box[+T <: Top] = ([K <: Top] -> (T => K) -> K)
 
@@ -16,6 +16,6 @@ def test[A <: Top, B <: Top] =
   def lazymap[A <: Top, B <: Top](b: Box[A])(f: A => B) =
     () => b[Box[B]]((x: A) => box(f(x)))
   val x0: (b: Box[A]) -> (f: A => B) -> (() -> Box[B]) = lazymap[A, B]  // error
-  val x: (b: Box[A]) -> (f: A => B) -> {b, f} (() -> Box[B]) = lazymap[A, B]  // works
-  val y: (b: Box[A]) -> (f: A => B) -> {*} (() -> Box[B]) = lazymap[A, B]  // works
+  val x: (b: Box[A]) -> (f: A => B) ->{b, f} (() -> Box[B]) = lazymap[A, B]  // works
+  val y: (b: Box[A]) -> (f: A => B) ->{cap} (() -> Box[B]) = lazymap[A, B]  // works
   ()

tests/neg-custom-args/capt-wf.scala

@@ -14,9 +14,9 @@ def test(c: Cap, other: String): Unit =
   val x5: C^{c, c} = ??? // error: redundant
   // val x6: C^{c}^{c} = ??? // would be syntax error
   val x7: Cap^{c} = ??? // error: redundant
-  // val x8: C^{c}^{*} = ??? // would be syntax error
-  val x9: C^{c, *}  = ??? // error: redundant
-  val x10: C^{*, c} = ??? // error: redundant
+  // val x8: C^{c}^{cap} = ??? // would be syntax error
+  val x9: C^{c, cap}  = ??? // error: redundant
+  val x10: C^{cap, c} = ??? // error: redundant
 
   def even(n: Int): Boolean = if n == 0 then true else odd(n - 1)
   def odd(n: Int): Boolean = if n == 1 then true else even(n - 1)

tests/neg-custom-args/captures/box-adapt-cases.scala

@@ -7,21 +7,21 @@ def test1(): Unit = {
   x(cap => cap.use())  // error
 }
 
-def test2(io: Cap^{*}): Unit = {
+def test2(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X -> T) -> T
 
   val x: Id[Cap^{io}] = ???
   x(cap => cap.use())  // error
 }
 
-def test3(io: Cap^{*}): Unit = {
+def test3(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io}] = ???
   x(cap => cap.use())  // ok
 }
 
-def test4(io: Cap^{*}, fs: Cap^{*}): Unit = {
+def test4(io: Cap^{cap}, fs: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io, fs}] = ???

tests/neg-custom-args/captures/box-adapt-cov.scala

@@ -1,12 +1,12 @@
 trait Cap
 
-def test1(io: Cap^{*}) = {
+def test1(io: Cap^{cap}) = {
   type Op[X] = [T] -> Unit -> X
   val f: Op[Cap^{io}] = ???
   val x: [T] -> Unit -> Cap^{io} = f  // error
 }
 
-def test2(io: Cap^{*}) = {
+def test2(io: Cap^{cap}) = {
   type Op[X] = [T] -> Unit -> X^{io}
   val f: Op[Cap^{io}] = ???
   val x: Unit -> Cap^{io} = f[Unit]  // error

tests/neg-custom-args/captures/box-adapt-cs.scala

@@ -1,14 +1,14 @@
 trait Cap { def use(): Int }
 
-def test1(io: Cap^{*}): Unit = {
+def test1(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io}] = ???
-  val f: (Cap^{*}) -> Unit = ???
+  val f: (Cap^{cap}) -> Unit = ???
   x(f)  // ok
 }
 
-def test2(io: Cap^{*}): Unit = {
+def test2(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X => T) -> T
 
   val x: Id[Cap^] = ???

tests/neg-custom-args/captures/box-adapt-depfun.scala

@@ -15,7 +15,7 @@ def test2(io: Cap^): Unit = {
   // should work when the expected type is a dependent function
 }
 
-def test3(io: Cap^{*}): Unit = {
+def test3(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: (x: X) ->{} T) -> T
 
   val x: Id[Cap^{io}] = ???

tests/neg-custom-args/captures/box-adapt-typefun.scala

@@ -1,12 +1,12 @@
 trait Cap { def use(): Int }
 
-def test1(io: Cap^{*}): Unit = {
+def test1(io: Cap^{cap}): Unit = {
   type Op[X] = [T] -> X -> Unit
   val f: [T] -> (Cap^{io}) -> Unit = ???
   val op: Op[Cap^{io}] = f // error
 }
 
-def test2(io: Cap^{*}): Unit = {
+def test2(io: Cap^{cap}): Unit = {
   type Lazy[X] = [T] -> Unit -> X
   val f: Lazy[Cap^{io}] = ???
   val test: [T] -> Unit -> (Cap^{io}) = f // error

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

@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 class Str
 
 def f(y: Cap, z: Cap) =

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

@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 class Str
 
 def f(y: Cap, z: Cap) =

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

@@ -2,8 +2,8 @@ import annotation.retains
 import language.experimental.erasedDefinitions
 
 class CT[E <: Exception]
-type CanThrow[E <: Exception] = CT[E] @retains(caps.*)
-type Top  = Any @retains(caps.*)
+type CanThrow[E <: Exception] = CT[E] @retains(caps.cap)
+type Top  = Any @retains(caps.cap)
 
 infix type throws[R, E <: Exception] = (erased CanThrow[E]) ?=> R
 

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

@@ -1,21 +1,21 @@
 import annotation.retains
 class C
-def f(x: C @retains(caps.*), y: C): () -> C =
+def f(x: C @retains(caps.cap), y: C): () -> C =
   () => if x == null then y else y  // error
 
-def g(x: C @retains(caps.*), y: C): Matchable =
+def g(x: C @retains(caps.cap), y: C): Matchable =
   () => if x == null then y else y  // error
 
-def h1(x: C @retains(caps.*), y: C): Any =
+def h1(x: C @retains(caps.cap), y: C): Any =
   def f() = if x == null then y else y
   () => f()  // ok
 
-def h2(x: C @retains(caps.*)): Matchable =
+def h2(x: C @retains(caps.cap)): Matchable =
   def f(y: Int) = if x == null then y else y  // error
   f
 
 class A
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 
 def h3(x: Cap): A =
   class F(y: Int) extends A:   // error
@@ -27,7 +27,7 @@ def h4(x: Cap, y: Int): A =
     def m() = if x == null then y else y
 
 def foo() =
-  val x: C @retains(caps.*) = ???
+  val x: C @retains(caps.cap) = ???
   def h[X](a: X)(b: X) = a
   val z2 = h[() -> Cap](() => x) // error
     (() => C())  // error

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

@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 
 def test1() =
   val x: Cap = C()

tests/neg-custom-args/captures/cc-this2.check

@@ -2,5 +2,5 @@
 -- Error: tests/neg-custom-args/captures/cc-this2/D_2.scala:2:6 --------------------------------------------------------
 2 |class D extends C: // error
   |^
-  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class C
+  |reference (scala.caps.cap : Any) is not included in allowed capture set {} of pure base class class C
 3 |  this: D^ =>

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

@@ -1,5 +1,5 @@
 import annotation.retains
 object Test:
 
-  def f[A <: Matchable @retains(caps.*)](x: A): Matchable = x // error
+  def f[A <: Matchable @retains(caps.cap)](x: A): Matchable = x // error
 

tests/neg-custom-args/captures/exception-definitions.check

@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:2:6 -----------------------------------------------
 2 |class Err extends Exception: // error
   |^
-  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class Throwable
+  |reference (scala.caps.cap : Any) is not included in allowed capture set {} of pure base class class Throwable
 3 |  self: Err^ =>
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:10:6 ----------------------------------------------
 10 |class Err4(c: Any^) extends AnyVal // error

tests/neg-custom-args/captures/heal-tparam-cs.scala

@@ -2,16 +2,16 @@ import language.experimental.captureChecking
 
 trait Cap { def use(): Unit }
 
-def localCap[T](op: (cap: Cap^{*}) => T): T = ???
+def localCap[T](op: (cap: Cap^{cap}) => T): T = ???
 
-def main(io: Cap^{*}, net: Cap^{*}): Unit = {
+def main(io: Cap^{cap}, net: Cap^{cap}): Unit = {
   val test1 = localCap { cap => // error
     () => { cap.use() }
   }
 
-  val test2: (cap: Cap^{*}) -> () ->{cap} Unit =
+  val test2: (cap: Cap^{cap}) -> () ->{cap} Unit =
     localCap { cap =>  // should work
-      (cap1: Cap^{*}) => () => { cap1.use() }
+      (cap1: Cap^{cap}) => () => { cap1.use() }
     }
 
   val test3: (cap: Cap^{io}) -> () ->{io} Unit =

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

@@ -1,8 +1,8 @@
 class Session:
   def request = "Response"
 class Foo:
-  private val session: Session^{*} = new Session
-  def withSession[T](f: (Session^{*}) => T): T = f(session)
+  private val session: Session^{cap} = new Session
+  def withSession[T](f: (Session^{cap}) => T): T = f(session)
 
 def Test =
   val f = new Foo