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

@@ -968,7 +968,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

@@ -1444,7 +1444,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
@@ -1681,7 +1680,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)