Make captureRoot an element of caps

This avoids the problem that we do not want to make `*` visible
under the scala package, even if pureFunctions or captureChecking is enabled.

Author: odersky

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -408,10 +408,10 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
 
     def apply(tp: ByNameTypeTree)(using Context): untpd.CapturingTypeTree =
       untpd.CapturingTypeTree(
-        Ident(nme.CAPTURE_ROOT).withSpan(tp.span.startPos) :: Nil, tp)
+        untpd.captureRoot.withSpan(tp.span.startPos) :: Nil, tp)
 
     def unapply(tp: Tree)(using Context): Option[ByNameTypeTree] = tp match
-      case untpd.CapturingTypeTree(id @ Ident(nme.CAPTURE_ROOT) :: Nil, bntp: ByNameTypeTree)
+      case untpd.CapturingTypeTree(id @ Select(_, nme.CAPTURE_ROOT) :: Nil, bntp: ByNameTypeTree)
       if id.span == bntp.span.startPos => Some(bntp)
       case _ => None
   end ImpureByNameTypeTree

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -492,6 +492,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def scalaAny(implicit src: SourceFile): Select = scalaDot(tpnme.Any)
   def javaDotLangDot(name: Name)(implicit src: SourceFile): Select = Select(Select(Ident(nme.java), nme.lang), name)
 
+  def captureRoot(using Context): Select =
+    Select(scalaDot(nme.caps), nme.CAPTURE_ROOT)
+
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)
 

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

@@ -470,7 +470,6 @@ class Definitions {
 
   @tu lazy val andType: TypeSymbol = enterBinaryAlias(tpnme.AND, AndType(_, _))
   @tu lazy val orType: TypeSymbol = enterBinaryAlias(tpnme.OR, OrType(_, _, soft = false))
-  @tu lazy val captureRoot: TermSymbol = enterPermanentSymbol(nme.CAPTURE_ROOT, AnyType).asTerm
 
   /** Method representing a throw */
   @tu lazy val throwMethod: TermSymbol = enterMethod(OpsPackageClass, nme.THROWkw,
@@ -964,6 +963,7 @@ class Definitions {
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
     @tu lazy val Caps_unsafeBox: Symbol = CapsModule.requiredMethod("unsafeBox")
     @tu lazy val Caps_unsafeUnbox: Symbol = CapsModule.requiredMethod("unsafeUnbox")
+    @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")
 
   // Annotation base classes
   @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
@@ -1984,9 +1984,8 @@ class Definitions {
     this.initCtx = ctx
     if (!isInitialized) {
       // force initialization of every symbol that is synthesized or hijacked by the compiler
-      val forced = syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses()
-        ++ (JavaEnumClass :: (if Feature.ccEnabled then captureRoot :: Nil else Nil))
-
+      val forced =
+        syntheticCoreClasses ++ syntheticCoreMethods ++ ScalaValueClasses() :+ JavaEnumClass
       isInitialized = true
     }
     addSyntheticSymbolsComments

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

@@ -425,6 +425,7 @@ object StdNames {
     val bytes: N                = "bytes"
     val canEqual_ : N           = "canEqual"
     val canEqualAny : N         = "canEqualAny"
+    val caps: N                 = "caps"
     val checkInitialized: N     = "checkInitialized"
     val classOf: N              = "classOf"
     val classType: N            = "classType"

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

@@ -159,7 +159,7 @@ object Parsers {
       syntaxError(msg.toMessage, span)
 
     def unimplementedExpr(using Context): Select =
-      Select(Select(rootDot(nme.scala), nme.Predef), nme.???)
+      Select(scalaDot(nme.Predef), nme.???)
   }
 
   trait OutlineParserCommon extends ParserCommon {
@@ -1444,7 +1444,10 @@ object Parsers {
     /** CaptureRef  ::=  ident | `this`
      */
     def captureRef(): Tree =
-      if in.token == THIS then simpleRef() else termIdent()
+      if in.token == THIS then simpleRef()
+      else termIdent() match
+        case Ident(nme.CAPTURE_ROOT) => captureRoot
+        case id => id
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
      */

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

@@ -376,6 +376,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: SingletonType => toTextRef(tp)
       case _ => toText(tp)
 

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

@@ -2682,7 +2682,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type) {
       val cls = annot1.symbol.maybeOwner
-      if ctx.settings.Ycc.value
+      if Feature.ccEnabled
           && (cls == defn.RetainsAnnot || cls == defn.RetainsByNameAnnot)
       then
         CheckCaptures.checkWellformed(annot1)

library/src/scala/caps.scala

@@ -5,6 +5,9 @@ import annotation.experimental
 @experimental
 object caps:
 
+  /** The universal capture reference */
+  val `*`: Any = ()
+
   /** If argument is of type `cs T`, converts to type `box cs T`. This
    *  avoids the error that would be raised when boxing `*`.
    */

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

@@ -1,7 +1,7 @@
 // No longer valid
 class C
-type Cap = C @retains(*)
-type Top = Any @retains(*)
+type Cap = C @retains(caps.*)
+type Top = Any @retains(caps.*)
 
 type T = (x: Cap) => List[String @retains(x)] => Unit // error
 val x: (x: Cap) => Array[String @retains(x)] = ??? // error

tests/disabled/neg-custom-args/captures/try2.scala

@@ -5,7 +5,7 @@ import annotation.ability
 @ability erased val canThrow: * = ???
 
 class CanThrow[E <: Exception] extends Retains[canThrow.type]
-type Top  = Any @retains(*)
+type Top  = Any @retains(caps.*)
 
 infix type throws[R, E <: Exception] = (erased CanThrow[E]) ?=> R
 

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

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

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

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

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(*)
-type Top  = Any @retains(*)
+type CanThrow[E <: Exception] = CT[E] @retains(caps.*)
+type Top  = Any @retains(caps.*)
 
 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(*), y: C): () -> C =
+def f(x: C @retains(caps.*), y: C): () -> C =
   () => if x == null then y else y  // error
 
-def g(x: C @retains(*), y: C): Matchable =
+def g(x: C @retains(caps.*), y: C): Matchable =
   () => if x == null then y else y  // error
 
-def h1(x: C @retains(*), y: C): Any =
+def h1(x: C @retains(caps.*), y: C): Any =
   def f() = if x == null then y else y
   () => f()  // ok
 
-def h2(x: C @retains(*)): Matchable =
+def h2(x: C @retains(caps.*)): Matchable =
   def f(y: Int) = if x == null then y else y  // error
   f
 
 class A
-type Cap = C @retains(*)
+type Cap = C @retains(caps.*)
 
 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(*) = ???
+  val x: C @retains(caps.*) = ???
   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(*)
+type Cap = C @retains(caps.*)
 
 def test1() =
   val x: Cap = C()

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

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

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

@@ -3,17 +3,17 @@ sealed trait IO:
   def puts(msg: Any): Unit = println(msg)
 
 def test1 =
-  val IO : IO @retains(*) = new IO {}
+  val IO : IO @retains(caps.*) = new IO {}
   def foo = {IO; IO.puts("hello") }
   val x : () -> Unit = () => foo  // error: Found: (() -> Unit) retains IO; Required: () -> Unit
 
 def test2 =
-  val IO : IO @retains(*) = new IO {}
-  def puts(msg: Any, io: IO @retains(*)) = println(msg)
+  val IO : IO @retains(caps.*) = new IO {}
+  def puts(msg: Any, io: IO @retains(caps.*)) = println(msg)
   def foo() = puts("hello", IO)
   val x : () -> Unit = () => foo()  // error: Found: (() -> Unit) retains IO; Required: () -> Unit
 
-type Capability[T] = T @retains(*)
+type Capability[T] = T @retains(caps.*)
 
 def test3 =
   val IO : Capability[IO] = new IO {}

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

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

tests/pos-custom-args/captures/boxmap.scala

@@ -1,5 +1,5 @@
 import annotation.retains
-type Top = Any @retains(*)
+type Top = Any @retains(caps.*)
 
 type Box[+T <: Top] = ([K <: Top] -> (T => K) -> K)
 

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

@@ -1,14 +1,14 @@
 import annotation.retains
 class C
-type Cap = C @retains(*)
+type Cap = C @retains(caps.*)
 
 type T = (x: Cap) -> String @retains(x)
 
 type ID[X] = X
 
 val aa: ((x: Cap) -> String @retains(x)) = (x: Cap) => ""
 
-def f(y: Cap, z: Cap): String @retains(*) =
+def f(y: Cap, z: Cap): String @retains(caps.*) =
   val a: ((x: Cap) -> String @retains(x)) = (x: Cap) => ""
   val b = a(y)
   val c: String @retains(y) = b

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

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

tests/pos-custom-args/captures/capt0.scala

@@ -3,5 +3,5 @@ object Test:
   def test() =
     val x: {*} Any = "abc"
     val y: Object @scala.annotation.retains(x) = ???
-    val z: Object @scala.annotation.retains(x, *) = y: Object @annotation.retains(x)
+    val z: Object @scala.annotation.retains(x, caps.*) = y: Object @annotation.retains(x)
 

tests/pos-custom-args/captures/capt2.scala

@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(*)
+type Cap = C @retains(caps.*)
 
 def test1() =
   val y: {*} String = ""

tests/pos-custom-args/captures/cc-expand.scala

@@ -5,7 +5,7 @@ object Test:
   class B
   class C
   class CTC
-  type CT = CTC @retains(*)
+  type CT = CTC @retains(caps.*)
 
   def test(ct: CT, dt: CT) =
 

tests/pos-custom-args/captures/try.scala

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