Rename @unbox to @use

odersky · odersky · commit ca0a6f9435cf · 2024-10-30T12:27:12.000+01:00
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -387,7 +387,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       def checkUseDeclared(c: CaptureRef, env: Env) =
         c.pathRoot match
-          case ref: NamedType if !ref.symbol.hasAnnotation(defn.UnboxAnnot) =>
+          case ref: NamedType if !ref.symbol.hasAnnotation(defn.UseAnnot) =>
             val what = if ref.isType then "Capture set parameter" else "Local reach capability"
             report.error(
               em"""$what $c leaks into capture scope of ${env.ownerString}.
@@ -519,7 +519,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def prepareFunction(funtpe: MethodType, meth: Symbol)(using Context): MethodType =
       val paramInfosWithUses = funtpe.paramInfos.zipWithConserve(funtpe.paramNames): (formal, pname) =>
         val paramOpt = meth.rawParamss.nestedFind(_.name == pname)
-        paramOpt.flatMap(_.getAnnotation(defn.UnboxAnnot)) match
+        paramOpt.flatMap(_.getAnnotation(defn.UseAnnot)) match
           case Some(ann) => AnnotatedType(formal, ann)
           case _ => formal
       funtpe.derivedLambdaType(paramInfos = paramInfosWithUses)
@@ -567,7 +567,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     def recheckArg(arg: Tree, formal: Type)(using Context): Type =
       val argType = recheck(arg, formal)
       formal match
-        case AnnotatedType(formal1, ann) if ann.symbol == defn.UnboxAnnot =>
+        case AnnotatedType(formal1, ann) if ann.symbol == defn.UseAnnot =>
           capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
           markFree(argType.deepCaptureSet, arg.srcPos)
         case _ =>
@@ -581,13 +581,13 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  ---------------------
      *  E |- f(a): Tr^C
      *
-     *  If the function `f` does not have an `@unboxed` parameter, then
+     *  If the function `f` does not have an `@use` parameter, then
      *  any unboxing it does would be charged to the environment of the function
      *  so they have to appear in Cq. Since any capabilities of the result of the
      *  application must already be present in the application, an upper
      *  approximation of the result capture set is Cq \union Ca, where `Ca`
      *  is the capture set of the argument.
-     *  If the function `f` does have an `@unboxed` parameter, then it could in addition
+     *  If the function `f` does have an `@use` parameter, then it could in addition
      *  unbox reach capabilities over its formal parameter. Therefore, the approximation
      *  would be `Cq \union dcs(Ca)` instead.
      *  If the approximation is known to subcapture the declared result Cr, we pick it for C
@@ -600,7 +600,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val argCaptures =
         for (argType, formal) <- argTypes.lazyZip(funType.paramInfos) yield
           formal match
-            case AnnotatedType(_, ann) if ann.symbol == defn.UnboxAnnot => argType.deepCaptureSet
+            case AnnotatedType(_, ann) if ann.symbol == defn.UseAnnot => argType.deepCaptureSet
             case _ => argType.captureSet
       appType match
         case appType @ CapturingType(appType1, refs)
@@ -1379,16 +1379,16 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         override def checkInheritedTraitParameters: Boolean = false
 
-        /** Check that overrides don't change the @unbox status of their parameters */
+        /** Check that overrides don't change the @use status of their parameters */
         override def additionalChecks(member: Symbol, other: Symbol)(using Context): Unit =
           for
             (params1, params2) <- member.rawParamss.lazyZip(other.rawParamss)
             (param1, param2) <- params1.lazyZip(params2)
           do
-            if param1.hasAnnotation(defn.UnboxAnnot) != param2.hasAnnotation(defn.UnboxAnnot) then
+            if param1.hasAnnotation(defn.UseAnnot) != param2.hasAnnotation(defn.UseAnnot) then
               report.error(
                 OverrideError(
-                    i"has a parameter ${param1.name} with different @unbox status than the corresponding parameter in the overridden definition",
+                    i"has a parameter ${param1.name} with different @use status than the corresponding parameter in the overridden definition",
                     self, member, other, self.memberInfo(member), self.memberInfo(other)
                   ),
                 if member.owner == clazz then member.srcPos else clazz.srcPos
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1057,12 +1057,12 @@ 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 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")
   @tu lazy val UncheckedCapturesAnnot: ClassSymbol = requiredClass("scala.annotation.unchecked.uncheckedCaptures")
   @tu lazy val UntrackedCapturesAnnot: ClassSymbol = requiredClass("scala.caps.untrackedCaptures")
+  @tu lazy val UseAnnot:  ClassSymbol = requiredClass("scala.caps.use")
   @tu lazy val VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
   @tu lazy val BeanGetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanGetter")
   @tu lazy val BeanSetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanSetter")
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
@@ -55,7 +55,7 @@ import annotation.{experimental, compileTimeOnly, retainsCap}
   /** 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
+  final class use extends annotation.StaticAnnotation
 
   object unsafe:
 
diff --git a/tests/neg-custom-args/captures/delayedRunops.scala b/tests/neg-custom-args/captures/delayedRunops.scala
@@ -1,12 +1,12 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
   // ok
-  def runOps(@unbox ops: List[() => Unit]): Unit =
+  def runOps(@use ops: List[() => Unit]): Unit =
     ops.foreach(op => op())
 
   // ok
-  def delayedRunOps(@unbox ops: List[() => Unit]): () ->{ops*} Unit = // @unbox should not be necessary in the future
+  def delayedRunOps(@use ops: List[() => Unit]): () ->{ops*} Unit = // @use should not be necessary in the future
     () => runOps(ops)
 
   // unsound: impure operation pretended pure
diff --git a/tests/neg-custom-args/captures/i15749a.scala b/tests/neg-custom-args/captures/i15749a.scala
@@ -1,5 +1,5 @@
 import caps.cap
-import caps.unbox
+import caps.use
 
 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](@unbox mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
+  def forceWrapper[A](@use 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
diff --git a/tests/neg-custom-args/captures/i21614.scala b/tests/neg-custom-args/captures/i21614.scala
@@ -1,12 +1,12 @@
 import language.experimental.captureChecking
 import caps.Capability
-import caps.unbox
+import caps.use
 
 trait File extends Capability
 class Logger(f: File^) extends Capability // <- will work if we remove the extends clause
 
-def mkLoggers1[F <: File^](@unbox files: List[F]): List[Logger^] =
+def mkLoggers1[F <: File^](@use files: List[F]): List[Logger^] =
   files.map((f: F) => new Logger(f)) // error, Q: can we make this pass (see #19076)?
 
-def mkLoggers2(@unbox files: List[File^]): List[Logger^] =
+def mkLoggers2(@use files: List[File^]): List[Logger^] =
   files.map(new Logger(_)) // error, Q: can we improve the error message?
diff --git a/tests/neg-custom-args/captures/leak-problem-2.scala b/tests/neg-custom-args/captures/leak-problem-2.scala
@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Source[+T]
 
-def race[T](@caps.unbox sources: Seq[Source[T]^]): Source[T]^{sources*} = ???
+def race[T](@caps.use sources: Seq[Source[T]^]): Source[T]^{sources*} = ???
 
 def raceTwo[T](src1: Source[T]^, src2: Source[T]^): Source[T]^{}
   = race(Seq(src1, src2)) // error
diff --git a/tests/neg-custom-args/captures/reaches.scala b/tests/neg-custom-args/captures/reaches.scala
@@ -1,4 +1,4 @@
-import caps.unbox
+import caps.use
 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(@unbox xs: List[Proc]): Unit =
+def runAll0(@use 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(@unbox xs: List[Proc]): Unit =
   usingFile: f =>
     cur = (() => f.write()) :: Nil // error
 
-def runAll1(@unbox xs: List[Proc]): Unit =
+def runAll1(@use 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](@unbox ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
+def mapCompose2[A](@use ps: List[(A => A, A => A)]): List[A ->{ps*} A] =
   ps.map((x, y) => compose1(x, y))
diff --git a/tests/neg-custom-args/captures/spread-problem.scala b/tests/neg-custom-args/captures/spread-problem.scala
@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Source[+T]
 
-def race[T](@caps.unbox sources: (Source[T]^)*): Source[T]^{sources*} = ???
+def race[T](@caps.use sources: (Source[T]^)*): Source[T]^{sources*} = ???
 
 def raceTwo[T](src1: Source[T]^, src2: Source[T]^): Source[T]^{} =
   race(Seq(src1, src2)*) // error
diff --git a/tests/neg-custom-args/captures/unbox-overrides.check b/tests/neg-custom-args/captures/unbox-overrides.check
@@ -2,20 +2,20 @@
 8 |  def foo(x: C): C        // error
   |      ^
   |error overriding method foo in trait A of type (x: C): C;
-  |  method foo of type (x: C): C has a parameter x with different @unbox status than the corresponding parameter in the overridden definition
+  |  method foo of type (x: C): C has a parameter x with different @use status than the corresponding parameter in the overridden definition
   |
   | longer explanation available when compiling with `-explain`
 -- [E164] Declaration Error: tests/neg-custom-args/captures/unbox-overrides.scala:9:6 ----------------------------------
-9 |  def bar(@unbox x: C): C // error
+9 |  def bar(@use x: C): C // error
   |      ^
   |error overriding method bar in trait A of type (x: C): C;
-  |  method bar of type (x: C): C has a parameter x with different @unbox status than the corresponding parameter in the overridden definition
+  |  method bar of type (x: C): C has a parameter x with different @use status than the corresponding parameter in the overridden definition
   |
   | longer explanation available when compiling with `-explain`
 -- [E164] Declaration Error: tests/neg-custom-args/captures/unbox-overrides.scala:15:15 --------------------------------
 15 |abstract class C extends A[C], B2 // error
    |               ^
    |error overriding method foo in trait A of type (x: C): C;
-   |  method foo in trait B2 of type (x: C): C has a parameter x with different @unbox status than the corresponding parameter in the overridden definition
+   |  method foo in trait B2 of type (x: C): C has a parameter x with different @use status than the corresponding parameter in the overridden definition
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/unbox-overrides.scala b/tests/neg-custom-args/captures/unbox-overrides.scala
@@ -1,15 +1,15 @@
-import caps.unbox
+import caps.use
 
 trait A[X]:
-  def foo(@unbox x: X): X
+  def foo(@use x: X): X
   def bar(x: X): X
 
 trait B extends A[C]:
   def foo(x: C): C        // error
-  def bar(@unbox x: C): C // error
+  def bar(@use x: C): C // error
 
 trait B2:
   def foo(x: C): C
-  def bar(@unbox x: C): C
+  def bar(@use x: C): C
 
 abstract class C extends A[C], B2 // error
diff --git a/tests/neg/i20503.scala b/tests/neg/i20503.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 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(@unbox ops: List[() => Unit]): Unit =
+def runOps(@use 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())
diff --git a/tests/neg/leak-problem-unboxed.scala b/tests/neg/leak-problem-unboxed.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 // 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(@unbox x: Box[Async^]): Unit =
+def useBoxedAsync(@use x: Box[Async^]): Unit =
   val t0 = x
   val t1 = t0.get // ok
   t1.read()
 
-def useBoxedAsync1(@unbox x: Box[Async^]): Unit = x.get.read() // ok
+def useBoxedAsync1(@use x: Box[Async^]): Unit = x.get.read() // ok
 
 def test(): Unit =
 
diff --git a/tests/neg/leak-problem.scala b/tests/neg/leak-problem.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 // Some capabilities that should be used locally
 trait Async:
@@ -17,12 +17,12 @@ def useBoxedAsync(x: Box[Async^]): Unit =
 def useBoxedAsync1(x: Box[Async^]): Unit = x.get.read() // error
 
 def test(): Unit =
-  def useBoxedAsync(@unbox x: Box[Async^]): Unit =
+  def useBoxedAsync(@use x: Box[Async^]): Unit =
     val t0 = x
     val t1 = t0.get
     t1.read()
 
-  def useBoxedAsync1(@unbox x: Box[Async^]): Unit = x.get.read()
+  def useBoxedAsync1(@use x: Box[Async^]): Unit = x.get.read()
 
   val xs: Box[Async^] = ???
   val xsLambda = () => useBoxedAsync(xs) // error
diff --git a/tests/pos-custom-args/captures/Buffer.scala b/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 @unbox. It's not inferred
+      // Alternative would be to mark `f` as @use. 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
diff --git a/tests/pos-custom-args/captures/dep-reach.scala b/tests/pos-custom-args/captures/dep-reach.scala
@@ -1,10 +1,10 @@
-import caps.unbox
+import caps.use
 object Test:
   class C
   type Proc = () => Unit
 
   def f(c: C^, d: C^): () ->{c, d} Unit =
-    def foo(@unbox xs: Proc*): () ->{xs*} Unit =
+    def foo(@use 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(@unbox xs: Seq[() => Unit]): () ->{xs*} Unit =
+    def foo(@use xs: Seq[() => Unit]): () ->{xs*} Unit =
       xs.head
 
     val a: () ->{c} Unit = () => ()
diff --git a/tests/pos-custom-args/captures/gears-problem.scala b/tests/pos-custom-args/captures/gears-problem.scala
@@ -1,5 +1,5 @@
 import language.experimental.captureChecking
-import caps.unbox
+import caps.use
 
 trait Future[+T]:
   def await: T
@@ -11,7 +11,7 @@ class Collector[T](val futures: Seq[Future[T]^]):
   val results: Channel[Future[T]^{futures*}] = ???
 end Collector
 
-extension [T](@unbox fs: Seq[Future[T]^])
+extension [T](@use fs: Seq[Future[T]^])
   def awaitAll =
     val collector: Collector[T]{val futures: Seq[Future[T]^{fs*}]}
        = Collector(fs)
diff --git a/tests/pos-custom-args/captures/path-use.scala b/tests/pos-custom-args/captures/path-use.scala
@@ -1,5 +1,5 @@
 import language.experimental.namedTuples
-import caps.unbox
+import caps.use
 
 class IO
 
@@ -9,7 +9,7 @@ class C(val f: IO^):
 type Proc = () => Unit
 
 def test(io: IO^) =
-  def test1(@unbox c: C { val f: IO^{io}}^{io}) =
+  def test1(@use c: C { val f: IO^{io}}^{io}) =
     val f = () => println(c.f)
     val _: () ->{c.f} Unit = f
 
@@ -19,3 +19,4 @@ def test(io: IO^) =
     val g = () => println(c.procs.head)
     val _: () ->{c.procs*} Unit = g
   test1(C(io))
+
diff --git a/tests/pos-custom-args/captures/reaches.scala b/tests/pos-custom-args/captures/reaches.scala
@@ -1,4 +1,4 @@
-import caps.unbox
+import caps.use
 
 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(@unbox xs: List[Proc]): Unit =
+def runAll(@use xs: List[Proc]): Unit =
   var cur: List[() ->{xs*} Unit] = xs  // OK, by revised VAR
   while cur.nonEmpty do
     val next: () ->{xs*} Unit = cur.head
diff --git a/tests/pos/Buffer.scala b/tests/pos/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 @unbox. It's not inferred
+      // Alternative would be to mark `f` as @use. 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
diff --git a/tests/pos/cc-poly-source-capability.scala b/tests/pos/cc-poly-source-capability.scala
diff --git a/tests/pos/cc-poly-source.scala b/tests/pos/cc-poly-source.scala
diff --git a/tests/pos/gears-probem-1.scala b/tests/pos/gears-probem-1.scala
diff --git a/tests/pos/i18699.scala b/tests/pos/i18699.scala
diff --git a/tests/pos/reach-capability.scala b/tests/pos/reach-capability.scala
diff --git a/tests/pos/reach-problem.scala b/tests/pos/reach-problem.scala
