Rename @unboxed --> @unbox

Author: odersky

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

@@ -395,7 +395,7 @@ class CheckCaptures extends Recheck, SymTransformer:
                 val refOwner = refSym.owner
                 val isVisible = isVisibleFromEnv(refOwner)
                 if !isVisible && c.isReach && refSym.is(Param) && refOwner == env.owner then
-                if refSym.hasAnnotation(defn.UnboxedAnnot) then
+                if refSym.hasAnnotation(defn.UnboxAnnot) then
                   capt.println(i"exempt: $ref in $refOwner")
                 else
                   // Reach capabilities that go out of scope have to be approximated
@@ -425,7 +425,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val unboxedParamNames =
         meth.rawParamss.flatMap: params =>
           params.collect:
-            case param if param.hasAnnotation(defn.UnboxedAnnot) =>
+            case param if param.hasAnnotation(defn.UnboxAnnot) =>
               param.name
         .toSet
 

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

@@ -1050,7 +1050,7 @@ class Definitions {
   @tu lazy val ExperimentalAnnot: ClassSymbol = requiredClass("scala.annotation.experimental")
   @tu lazy val ThrowsAnnot: ClassSymbol = requiredClass("scala.throws")
   @tu lazy val TransientAnnot: ClassSymbol = requiredClass("scala.transient")
-  @tu lazy val UnboxedAnnot:  ClassSymbol = requiredClass("scala.caps.unboxed")
+  @tu lazy val UnboxAnnot:  ClassSymbol = requiredClass("scala.caps.unbox")
   @tu lazy val UncheckedAnnot: ClassSymbol = requiredClass("scala.unchecked")
   @tu lazy val UncheckedStableAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedStable")
   @tu lazy val UncheckedVarianceAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedVariance")

library/src/scala/caps.scala

@@ -39,7 +39,10 @@ import annotation.{experimental, compileTimeOnly}
    */
   final class untrackedCaptures extends annotation.StaticAnnotation
 
-  final class unboxed extends annotation.StaticAnnotation
+  /** This should go into annotations. For now it is here, so that we
+   *  can experiment with it quickly between minor releases
+   */
+  final class unbox extends annotation.StaticAnnotation
 
   object unsafe:
 

scala2-library-cc/src/scala/collection/mutable/Buffer.scala

@@ -15,7 +15,6 @@ package mutable
 
 import scala.annotation.nowarn
 import language.experimental.captureChecking
-import caps.unboxed
 
 /** A `Buffer` is a growable and shrinkable `Seq`. */
 trait Buffer[A]
@@ -180,11 +179,11 @@ trait IndexedBuffer[A] extends IndexedSeq[A]
 
   override def iterableFactory: SeqFactory[IndexedBuffer] = IndexedBuffer
 
-  def flatMapInPlace(@unboxed f: A => IterableOnce[A]^): this.type = {
+  def flatMapInPlace(f: A => IterableOnce[A]^): this.type = {
     // There's scope for a better implementation which copies elements in place.
     var i = 0
     val s = size
-    val newElems = new Array[(IterableOnce[A]^{f*})](s)
+    val newElems = new Array[(IterableOnce[A]^{f})](s)
     while (i < s) { newElems(i) = f(this(i)); i += 1 }
     clear()
     i = 0

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

@@ -1,5 +1,5 @@
 import caps.cap
-import caps.unboxed
+import caps.unbox
 
 class Unit
 object u extends Unit
@@ -18,7 +18,7 @@ def test =
 
   def force[A](thunk: Unit ->{cap} A): A = thunk(u)
 
-  def forceWrapper[A](@unboxed mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
+  def forceWrapper[A](@unbox mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
     // Γ ⊢ mx: Wrapper[□ {cap} Unit => A]
     // `force` should be typed as ∀(□ {cap} Unit -> A) A, but it can not
     strictMap[Unit ->{mx*} A, A](mx)(t => force[A](t)) // error // should work

tests/neg-custom-args/captures/leak-problem-2.scala

@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Source[+T]
 
-def race[T](@caps.unboxed sources: Seq[Source[T]^]): Source[T]^{sources*} = ???
+def race[T](@caps.unbox sources: Seq[Source[T]^]): Source[T]^{sources*} = ???
 
 def raceTwo[T](src1: Source[T]^, src2: Source[T]^): Source[T]^{}
   = race(Seq(src1, src2)) // error

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

@@ -1,4 +1,4 @@
-import caps.unboxed
+import caps.unbox
 class File:
   def write(): Unit = ???
 
@@ -11,7 +11,7 @@ class Ref[T](init: T):
   def get: T = x
   def set(y: T) = { x = y }
 
-def runAll0(@unboxed xs: List[Proc]): Unit =
+def runAll0(@unbox xs: List[Proc]): Unit =
   var cur: List[() ->{xs*} Unit] = xs
   while cur.nonEmpty do
     val next: () ->{xs*} Unit = cur.head
@@ -21,7 +21,7 @@ def runAll0(@unboxed xs: List[Proc]): Unit =
   usingFile: f =>
     cur = (() => f.write()) :: Nil // error
 
-def runAll1(@unboxed xs: List[Proc]): Unit =
+def runAll1(@unbox xs: List[Proc]): Unit =
   val cur = Ref[List[() ->{xs*} Unit]](xs)  // OK, by revised VAR
   while cur.get.nonEmpty do
     val next: () ->{xs*} Unit = cur.get.head
@@ -78,5 +78,5 @@ def compose1[A, B, C](f: A => B, g: B => C): A ->{f, g} C =
 def mapCompose[A](ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
   ps.map((x, y) => compose1(x, y)) // error // error
 
-def mapCompose2[A](@unboxed ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
+def mapCompose2[A](@unbox ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
   ps.map((x, y) => compose1(x, y))

tests/neg/i20503.scala

@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unboxed
+import caps.unbox
 
 class List[+A]:
   def head: A = ???
@@ -8,7 +8,7 @@ class List[+A]:
   def foreach[U](f: A => U): Unit = ???
   def nonEmpty: Boolean = ???
 
-def runOps(@unboxed ops: List[() => Unit]): Unit =
+def runOps(@unbox ops: List[() => Unit]): Unit =
   // See i20156, due to limitation in expressiveness of current system,
   // we could map over the list of impure elements. OK with existentials.
   ops.foreach(op => op())

tests/neg/leak-problem-unboxed.scala

@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unboxed
+import caps.unbox
 
 // Some capabilities that should be used locally
 trait Async:
@@ -9,12 +9,12 @@ def usingAsync[X](op: Async^ => X): X = ???
 
 case class Box[+T](get: T)
 
-def useBoxedAsync(@unboxed x: Box[Async^]): Unit =
+def useBoxedAsync(@unbox x: Box[Async^]): Unit =
   val t0 = x
   val t1 = t0.get // ok
   t1.read()
 
-def useBoxedAsync1(@unboxed x: Box[Async^]): Unit = x.get.read() // ok
+def useBoxedAsync1(@unbox x: Box[Async^]): Unit = x.get.read() // ok
 
 def test(): Unit =
 

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

@@ -10,7 +10,7 @@ trait Buffer[A]:
     val s = 10
      // capture checking: we need the copy since we box/unbox on g* on the next line
       // TODO: This looks fishy, need to investigate
-      // Alternative would be to mark `f` as @unboxed. It's not inferred
+      // Alternative would be to mark `f` as @unbox. It's not inferred
       // since `^ appears in a function result, not under a box.
     val newElems = new Array[(IterableOnce[A]^{f})](s)
     var i = 0

tests/pos-custom-args/captures/dep-reach.scala

@@ -1,10 +1,10 @@
-import caps.unboxed
+import caps.unbox
 object Test:
   class C
   type Proc = () => Unit
 
   def f(c: C^, d: C^): () ->{c, d} Unit =
-    def foo(@unboxed xs: Proc*): () ->{xs*} Unit =
+    def foo(@unbox xs: Proc*): () ->{xs*} Unit =
       xs.head
     val a: () ->{c} Unit = () => ()
     val b: () ->{d} Unit = () => ()
@@ -13,7 +13,7 @@ object Test:
 
   def g(c: C^, d: C^): () ->{c, d} Unit =
 
-    def foo(@unboxed xs: Seq[() => Unit]): () ->{xs*} Unit =
+    def foo(@unbox xs: Seq[() => Unit]): () ->{xs*} Unit =
       xs.head
 
     val a: () ->{c} Unit = () => ()

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

@@ -1,4 +1,4 @@
-import caps.unboxed
+import caps.unbox
 
 class C
 def f(xs: List[C^]) =
@@ -22,7 +22,7 @@ extension [A](x: A) def :: (xs: List[A]): List[A] = ???
 
 object Nil extends List[Nothing]
 
-def runAll(@unboxed xs: List[Proc]): Unit =
+def runAll(@unbox xs: List[Proc]): Unit =
   var cur: List[() ->{xs*} Unit] = xs  // OK, by revised VAR
   while cur.nonEmpty do
     val next: () ->{xs*} Unit = cur.head

tests/pos/cc-poly-source-capability.scala

@@ -1,7 +1,7 @@
 import language.experimental.captureChecking
 import annotation.experimental
 import caps.{CapSet, Capability}
-import caps.unboxed
+import caps.unbox
 
 @experimental object Test:
 
@@ -18,7 +18,7 @@ import caps.unboxed
 
     def allListeners: Set[Listener^{X^}] = listeners
 
-  def test1(async1: Async, @unboxed others: List[Async]) =
+  def test1(async1: Async, @unbox others: List[Async]) =
     val src = Source[CapSet^{async1, others*}]
     val lst1 = listener(async1)
     val lsts = others.map(listener)

tests/pos/cc-poly-source.scala

@@ -1,7 +1,7 @@
 import language.experimental.captureChecking
 import annotation.experimental
 import caps.{CapSet, Capability}
-import caps.unboxed
+import caps.unbox
 
 @experimental object Test:
 
@@ -25,7 +25,7 @@ import caps.unboxed
     val ls = src.allListeners
     val _: Set[Listener^{lbl1, lbl2}] = ls
 
-  def test2(@unboxed lbls: List[Label^]) =
+  def test2(@unbox lbls: List[Label^]) =
     def makeListener(lbl: Label^): Listener^{lbl} = ???
     val listeners = lbls.map(makeListener)
     val src = Source[CapSet^{lbls*}]

tests/pos/gears-probem-1.scala

@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unboxed
+import caps.unbox
 
 trait Future[+T]:
   def await: T
@@ -17,7 +17,7 @@ class Result[+T, +E]:
 case class Err[+E](e: E) extends Result[Nothing, E]
 case class Ok[+T](x: T) extends Result[T, Nothing]
 
-extension [T](@unboxed fs: Seq[Future[T]^])
+extension [T](@unbox fs: Seq[Future[T]^])
   def awaitAll =
     val collector//: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)

tests/pos/i18699.scala

@@ -1,9 +1,9 @@
 import language.experimental.captureChecking
-import caps.unboxed
+import caps.unbox
 
 trait Cap:
   def use: Int = 42
 
-def test2(@unboxed cs: List[Cap^]): Unit =
+def test2(@unbox cs: List[Cap^]): Unit =
   val t0: Cap^{cs*} = cs.head  // error
   var t1: Cap^{cs*} = cs.head  // error

tests/pos/reach-capability.scala

@@ -1,7 +1,7 @@
 import language.experimental.captureChecking
 import annotation.experimental
 import caps.Capability
-import caps.unboxed
+import caps.unbox
 
 @experimental object Test2:
 
@@ -12,7 +12,7 @@ import caps.unboxed
 
   class Listener
 
-  def test2(@unboxed lbls: List[Label]) =
+  def test2(@unbox lbls: List[Label]) =
     def makeListener(lbl: Label): Listener^{lbl} = ???
     val listeners = lbls.map(makeListener) // should work
 

tests/pos/reach-problem.scala

@@ -1,11 +1,11 @@
 import language.experimental.captureChecking
-import caps.unboxed
+import caps.unbox
 
 class Box[T](items: Seq[T^]):
   def getOne: T^{items*} = ???
 
 object Box:
-  def getOne[T](@unboxed items: Seq[T^]): T^{items*} =
+  def getOne[T](@unbox items: Seq[T^]): T^{items*} =
     val bx = Box(items)
     bx.getOne
 /*