Enhancement: Add unsafeBoxFunArg operation.

We need an unsafe transform from

    {*} A => B

to

    box {*} A => B

I don't think this is expressible with `unsafeBox/unsafeUnbox` alone.

Author: odersky

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

@@ -337,12 +337,21 @@ class CheckCaptures extends Recheck, SymTransformer:
     override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
       val meth = tree.fun.symbol
       includeCallCaptures(meth, tree.srcPos)
-      if meth == defn.Caps_unsafeBox || meth == defn.Caps_unsafeUnbox then
+      def mapArgUsing(f: Type => Type) =
         val arg :: Nil = tree.args: @unchecked
-        val argType0 = recheckStart(arg, pt)
-          .forceBoxStatus(boxed = meth == defn.Caps_unsafeBox)
+        val argType0 = f(recheckStart(arg, pt))
         val argType = super.recheckFinish(argType0, arg, pt)
         super.recheckFinish(argType, tree, pt)
+
+      if meth == defn.Caps_unsafeBox then
+        mapArgUsing(_.forceBoxStatus(true))
+      else if meth == defn.Caps_unsafeUnbox then
+        mapArgUsing(_.forceBoxStatus(false))
+      else if meth == defn.Caps_unsafeBoxFunArg then
+        mapArgUsing {
+          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual, isErased) =>
+            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual, isErased)
+        }
       else
         super.recheckApply(tree, pt) match
           case appType @ CapturingType(appType1, refs) =>

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

@@ -963,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 Caps_unsafeBoxFunArg: Symbol = CapsModule.requiredMethod("unsafeBoxFunArg")
     @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")
 
   // Annotation base classes

library/src/scala/caps.scala

@@ -17,6 +17,11 @@ import annotation.experimental
    */
   extension [T](x: T) def unsafeUnbox: T = x
 
+  /** If argument is of type `box cs T`, converts to type `cs T`. This
+   *  avoids the error that would be raised when unboxing `*`.
+   */
+  extension [T, U](f: T => U) def unsafeBoxFunArg: T => U = f
+
   /** Mixing in this trait forces a trait or class to be pure, i.e.
    *  have no capabilities retained in its self type.
    */

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

@@ -0,0 +1,4 @@
+import caps.*
+def test =
+  val tasks = new collection.mutable.ArrayBuffer[() => Unit]
+  val _: Unit = tasks.foreach(((task: () => Unit) => task()).unsafeBoxFunArg)