Require cap to be imported from caps.

odersky · odersky · commit 927dec123122 · 2023-11-14T10:47:34.000+01:00
Since it is never necessary to write `cap` explicitly, there's no need to treat the
identifier as a soft keyword.
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1474,15 +1474,13 @@ object Parsers {
      */
     def captureRef(): Tree =
       if in.token == THIS then simpleRef()
-      else termIdent() match
-        case id @ Ident(nme.CAPTURE_ROOT) =>
-          atSpan(id.span.start)(captureRoot)
-        case id =>
-          if isIdent(nme.raw.STAR) then
-            in.nextToken()
-            atSpan(startOffset(id)):
-              Select(id, nme.CC_REACH)
-          else id
+      else
+        val id = termIdent()
+        if isIdent(nme.raw.STAR) then
+          in.nextToken()
+          atSpan(startOffset(id)):
+            Select(id, nme.CC_REACH)
+        else id
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
      */
diff --git a/tests/neg-custom-args/captures/box-adapt-cases.scala b/tests/neg-custom-args/captures/box-adapt-cases.scala
@@ -7,21 +7,21 @@ def test1(): Unit = {
   x(cap => cap.use())  // was error, now OK
 }
 
-def test2(io: Cap^{cap}): Unit = {
+def test2(io: Cap^): Unit = {
   type Id[X] = [T] -> (op: X -> T) -> T
 
   val x: Id[Cap^{io}] = ???
   x(cap => cap.use())  // error
 }
 
-def test3(io: Cap^{cap}): Unit = {
+def test3(io: 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^{cap}, fs: Cap^{cap}): Unit = {
+def test4(io: Cap^, fs: Cap^): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io, fs}] = ???
diff --git a/tests/neg-custom-args/captures/box-adapt-contra.scala b/tests/neg-custom-args/captures/box-adapt-contra.scala
@@ -15,4 +15,4 @@ def test2(c: Cap^, d: Cap^): Unit =
   val f2: (Cap^{c} -> Unit) ->{c} Unit = useCap2[Cap^{c}](c)  // ok
 
   def useCap3[X](x: X): (X ->{d} Unit) -> Unit = ???
-  val f3: (Cap^{c} -> Unit) ->{cap} Unit = useCap3[Cap^{c}](c)  // error
+  val f3: (Cap^{c} -> Unit) => Unit = useCap3[Cap^{c}](c)  // error
diff --git a/tests/neg-custom-args/captures/box-adapt-cov.scala b/tests/neg-custom-args/captures/box-adapt-cov.scala
@@ -1,12 +1,12 @@
 trait Cap
 
-def test1(io: Cap^{cap}) = {
+def test1(io: Cap^) = {
   type Op[X] = [T] -> Unit -> X
   val f: Op[Cap^{io}] = ???
   val x: [T] -> Unit -> Cap^{io} = f  // error
 }
 
-def test2(io: Cap^{cap}) = {
+def test2(io: Cap^) = {
   type Op[X] = [T] -> Unit -> X^{io}
   val f: Op[Cap^{io}] = ???
   val x: Unit -> Cap^{io} = f[Unit]  // error
diff --git a/tests/neg-custom-args/captures/box-adapt-cs.scala b/tests/neg-custom-args/captures/box-adapt-cs.scala
@@ -1,14 +1,14 @@
 trait Cap { def use(): Int }
 
-def test1(io: Cap^{cap}): Unit = {
+def test1(io: Cap^): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io}] = ???
-  val f: (Cap^{cap}) -> Unit = ???
+  val f: (Cap^) -> Unit = ???
   x(f)  // ok
 }
 
-def test2(io: Cap^{cap}): Unit = {
+def test2(io: Cap^): Unit = {
   type Id[X] = [T] -> (op: X => T) -> T
 
   val x: Id[Cap^] = ???
diff --git a/tests/neg-custom-args/captures/box-adapt-depfun.scala b/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^{cap}): Unit = {
+def test3(io: Cap^): Unit = {
   type Id[X] = [T] -> (op: (x: X) ->{} T) -> T
 
   val x: Id[Cap^{io}] = ???
diff --git a/tests/neg-custom-args/captures/box-adapt-typefun.scala b/tests/neg-custom-args/captures/box-adapt-typefun.scala
@@ -1,12 +1,12 @@
 trait Cap { def use(): Int }
 
-def test1(io: Cap^{cap}): Unit = {
+def test1(io: 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^{cap}): Unit = {
+def test2(io: Cap^): Unit = {
   type Lazy[X] = [T] -> Unit -> X
   val f: Lazy[Cap^{io}] = ???
   val test: [T] -> Unit -> (Cap^{io}) = f // error
diff --git a/tests/neg-custom-args/captures/cc-glb.scala b/tests/neg-custom-args/captures/cc-glb.scala
@@ -3,6 +3,6 @@ trait Cap
 trait Foo[+T]
 
 def magic[T](io: Cap^, x: Foo[T]^{io}): Foo[T]^{} =
-  val x1: Foo[T]^{cap} & Foo[Any]^{io} = x
+  val x1: (Foo[T]^) & Foo[Any]^{io} = x
   val x2: Foo[T] = x1  // error
   x2  // boom, an impure value becomes pure
diff --git a/tests/neg-custom-args/captures/heal-tparam-cs.scala b/tests/neg-custom-args/captures/heal-tparam-cs.scala
@@ -2,17 +2,17 @@ import language.experimental.captureChecking
 
 trait Capp { def use(): Unit }
 
-def localCap[sealed T](op: (c: Capp^{cap}) => T): T = ???
+def localCap[sealed T](op: (c: Capp^) => T): T = ???
 
-def main(io: Capp^{cap}, net: Capp^{cap}): Unit = {
+def main(io: Capp^, net: Capp^): Unit = {
 
   val test1 = localCap { c => // error
     () => { c.use() }
   }
 
-  val test2: (c: Capp^{cap}) -> () ->{cap} Unit =
+  val test2: (c: Capp^) -> () => Unit =
     localCap { c =>  // should work
-      (c1: Capp^{cap}) => () => { c1.use() }
+      (c1: Capp^) => () => { c1.use() }
     }
 
   val test3: (c: Capp^{io}) -> () ->{io} Unit =
diff --git a/tests/neg-custom-args/captures/i15049.scala b/tests/neg-custom-args/captures/i15049.scala
@@ -1,7 +1,7 @@
 class Session:
   def request = "Response"
 class Foo:
-  private val session: Session^{cap} = new Session
+  private val session: Session^ = new Session
   def withSession[sealed T](f: Session^ => T): T = f(session)
 
 def Test: Unit =
diff --git a/tests/neg-custom-args/captures/i16114.scala b/tests/neg-custom-args/captures/i16114.scala
@@ -11,7 +11,7 @@ def withCap[T](op: Cap^ => T): T = {
 }
 
 def main(fs: Cap^): Unit = {
-  def badOp(io: Cap^{cap}): Unit ->{} Unit = {
+  def badOp(io: Cap^): Unit ->{} Unit = {
     val op1: Unit ->{io} Unit = (x: Unit) =>
       expect[Cap^] {
         io.use()
diff --git a/tests/neg-custom-args/captures/lazylists1.scala b/tests/neg-custom-args/captures/lazylists1.scala
@@ -1,8 +1,8 @@
 class CC
-type Cap = CC^{cap}
+type Cap = CC^
 
 trait LazyList[+A]:
-  this: LazyList[A]^{cap} =>
+  this: LazyList[A]^ =>
 
   def isEmpty: Boolean
   def head: A
@@ -13,7 +13,7 @@ object LazyNil extends LazyList[Nothing]:
   def head = ???
   def tail = ???
 
-extension [A](xs: LazyList[A]^{cap})
+extension [A](xs: LazyList[A]^)
   def map[B](f: A => B): LazyList[B]^{xs, f} =
     final class Mapped extends LazyList[B]:
       this: (Mapped^{xs, f}) =>
diff --git a/tests/neg-custom-args/captures/leaked-curried.scala b/tests/neg-custom-args/captures/leaked-curried.scala
@@ -4,7 +4,7 @@ trait Cap:
 def withCap[T](op: (x: Cap^) => T): T = ???
 
 trait Box:
-  val get: () ->{} () ->{cap} Cap^
+  val get: () ->{} () => Cap^
 
 def main(): Unit =
   val leaked = withCap: (io: Cap^) =>
diff --git a/tests/neg-custom-args/captures/override-adapt-box-selftype.scala b/tests/neg-custom-args/captures/override-adapt-box-selftype.scala
@@ -15,7 +15,7 @@ object Test1 {
   }
 }
 
-def Test2(io: IO^{cap}, fs: IO^{io}, ct: IO^) = {
+def Test2(io: IO^, fs: IO^{io}, ct: IO^) = {
   abstract class A[X] { this: A[X]^{io} =>
     def foo(x: X): X
   }
diff --git a/tests/neg-custom-args/captures/override-adapt-box.scala b/tests/neg-custom-args/captures/override-adapt-box.scala
@@ -7,7 +7,7 @@ abstract class A[X] { this: A[X]^{} =>
 class IO
 class C
 
-def test(io: IO^{cap}) = {
+def test(io: IO^) = {
   class B extends A[C^{io}] {  // X =:= {io} C  // error
     override def foo(x: C^{io}): C^{io} = ???
   }
diff --git a/tests/neg-custom-args/captures/override-boxed.scala b/tests/neg-custom-args/captures/override-boxed.scala
@@ -1,7 +1,7 @@
 
 class A
 
-def test(x: Any^{cap}) =
+def test(x: Any^) =
   abstract class Getter:
     def get(): A^{x}
   class PolyGetter[T <: A^{x}] extends Getter:
diff --git a/tests/neg-custom-args/captures/singletons.scala b/tests/neg-custom-args/captures/singletons.scala
@@ -3,4 +3,4 @@ val x = () => ()
 val y1: x.type = x          // ok
 val y2: x.type^{} = x       // error: singleton type cannot have capture set
 val y3: x.type^{x} = x      // error: singleton type cannot have capture set // error
-val y4: x.type^{cap} = x    // error: singleton type cannot have capture set
+val y4: x.type^ = x         // error: singleton type cannot have capture set
diff --git a/tests/neg/capt-wf.scala b/tests/neg/capt-wf.scala
@@ -1,5 +1,5 @@
 //> using options -language:experimental.captureChecking -Xfatal-warnings
-
+import caps.cap
 class C
 type Cap = C^
 
diff --git a/tests/pos-custom-args/captures/byname.scala b/tests/pos-custom-args/captures/byname.scala
@@ -1,4 +1,5 @@
 import annotation.retainsByName
+import caps.cap
 class CC
 type Cap = CC^
 
diff --git a/tests/pos-custom-args/captures/capt1.scala b/tests/pos-custom-args/captures/capt1.scala
@@ -3,7 +3,7 @@ type Cap = C^
 def f1(c: Cap): () ->{c} c.type = () => c // ok
 
 def f2: Int =
-  val g: Boolean ->{cap} Int = ???
+  val g: Boolean => Int = ???
   val x = g(true)
   x
 
diff --git a/tests/pos-custom-args/captures/i15749.scala b/tests/pos-custom-args/captures/i15749.scala
@@ -1,9 +1,9 @@
 class Unit
 object unit extends Unit
 
-type Top = Any^{cap}
+type Top = Any^
 
-type LazyVal[T] = Unit ->{cap} T
+type LazyVal[T] = Unit => T
 
 class Foo[T](val x: T)
 
diff --git a/tests/pos-custom-args/captures/i15749a.scala b/tests/pos-custom-args/captures/i15749a.scala
@@ -1,3 +1,4 @@
+import caps.cap
 class Unit
 object u extends Unit
 
diff --git a/tests/pos-custom-args/captures/i15923-cases.scala b/tests/pos-custom-args/captures/i15923-cases.scala
@@ -2,14 +2,14 @@ trait Cap { def use(): Int }
 type Id[X] = [T] -> (op: X => T) -> T
 def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
 
-def foo(x: Id[Cap^{cap}]) = {
+def foo(x: Id[Cap^]) = {
   x(_.use())  // was error, now OK
 }
 
-def bar(io: Cap^{cap}, x: Id[Cap^{io}]) = {
+def bar(io: Cap^, x: Id[Cap^{io}]) = {
   x(_.use())
 }
 
-def barAlt(a: Cap^{cap}, b: Cap^{cap}, x: Id[Cap]^{a, b}) = {
+def barAlt(a: Cap^, b: Cap^, x: Id[Cap]^{a, b}) = {
   x(_.use())
 }
diff --git a/tests/pos-custom-args/captures/nested-classes-2.scala b/tests/pos-custom-args/captures/nested-classes-2.scala
@@ -11,7 +11,7 @@ def test1(x: (() => Unit)): Unit =
 
 def test2(x1: (() => Unit), x2: (() => Unit) => Unit) =
   class C1(x1: (() => Unit), xx2: (() => Unit) => Unit):
-    def c2(y1: (() => Unit), y2: (() => Unit) => Unit): C2^{cap} = C2(y1, y2)
+    def c2(y1: (() => Unit), y2: (() => Unit) => Unit): C2^ = C2(y1, y2)
     class C2(y1: (() => Unit), y2: (() => Unit) => Unit):
       val a: (() => Unit) => (() => Unit) = f(y1)
       a(x1)            //OK, but should be error
diff --git a/tests/pos/boxmap-paper.scala b/tests/pos/boxmap-paper.scala
@@ -19,7 +19,7 @@ def lazyMap[A, B](c: Cell[A])(f: A => B): () ->{f} Cell[B]
 trait IO:
   def print(s: String): Unit
 
-def test(io: IO^{cap}) =
+def test(io: IO^) =
 
   val loggedOne: () ->{io} Int = () => { io.print("1"); 1 }
 

Original file line number	Diff line number	Diff line change
`@@ -7,21 +7,21 @@ def test1(): Unit = {`
`7`	`7`	`x(cap => cap.use()) // was error, now OK`
`8`	`8`	`}`
`9`	`9`
`10`		`-def test2(io: Cap^{cap}): Unit = {`
	`10`	`+def test2(io: Cap^): Unit = {`
`11`	`11`	`type Id[X] = [T] -> (op: X -> T) -> T`
`12`	`12`
`13`	`13`	`val x: Id[Cap^{io}] = ???`
`14`	`14`	`x(cap => cap.use()) // error`
`15`	`15`	`}`
`16`	`16`
`17`		`-def test3(io: Cap^{cap}): Unit = {`
	`17`	`+def test3(io: Cap^): Unit = {`
`18`	`18`	`type Id[X] = [T] -> (op: X ->{io} T) -> T`
`19`	`19`
`20`	`20`	`val x: Id[Cap^{io}] = ???`
`21`	`21`	`x(cap => cap.use()) // ok`
`22`	`22`	`}`
`23`	`23`
`24`		`-def test4(io: Cap^{cap}, fs: Cap^{cap}): Unit = {`
	`24`	`+def test4(io: Cap^, fs: Cap^): Unit = {`
`25`	`25`	`type Id[X] = [T] -> (op: X ->{io} T) -> T`
`26`	`26`
`27`	`27`	`val x: Id[Cap^{io, fs}] = ???`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ def test2(io: Cap^): Unit = {`
`15`	`15`	`// should work when the expected type is a dependent function`
`16`	`16`	`}`
`17`	`17`
`18`		`-def test3(io: Cap^{cap}): Unit = {`
	`18`	`+def test3(io: Cap^): Unit = {`
`19`	`19`	`type Id[X] = [T] -> (op: (x: X) ->{} T) -> T`
`20`	`20`
`21`	`21`	`val x: Id[Cap^{io}] = ???`