Add capture checking to some standard library classes

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

@@ -362,7 +362,15 @@ class CheckCaptures extends Recheck, SymTransformer:
         val argType0 = f(recheckStart(arg, pt))
         val argType = super.recheckFinish(argType0, arg, pt)
         super.recheckFinish(argType, tree, pt)
-      if meth == defn.Caps_unsafeBox then
+
+      if meth == defn.Caps_unsafeAssumePure then
+        val arg :: Nil = tree.args: @unchecked
+        val argType0 = recheck(arg, pt.capturing(CaptureSet.universal))
+        val argType = if argType0.captureSet.isAlwaysEmpty then argType0
+        else argType0.widen.stripCapturing
+        capt.println(i"rechecking $arg with ${pt.capturing(CaptureSet.universal)}: $argType")
+        super.recheckFinish(argType, tree, pt)
+      else if meth == defn.Caps_unsafeBox then
         mapArgUsing(_.forceBoxStatus(true))
       else if meth == defn.Caps_unsafeUnbox then
         mapArgUsing(_.forceBoxStatus(false))

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

@@ -971,6 +971,7 @@ class Definitions {
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
     @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("cap")
     @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
+    @tu lazy val Caps_unsafeAssumePure: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumePure")
     @tu lazy val Caps_unsafeBox: Symbol = CapsUnsafeModule.requiredMethod("unsafeBox")
     @tu lazy val Caps_unsafeUnbox: Symbol = CapsUnsafeModule.requiredMethod("unsafeUnbox")
     @tu lazy val Caps_unsafeBoxFunArg: Symbol = CapsUnsafeModule.requiredMethod("unsafeBoxFunArg")

library/src/scala/annotation/internal/WithPureFuns.scala

@@ -1,6 +1,5 @@
 package scala.annotation
 package internal
-import annotation.experimental
 
 /** A marker annotation on a toplevel class that indicates
  *  that the class was typed with the pureFunctions language import.

library/src/scala/caps.scala

@@ -14,6 +14,12 @@ import annotation.experimental
   object unsafe:
 
     extension [T](x: T)
+      /** A specific cast operation to remove a capture set.
+       *  If argument is of type `T^C`, assume it is of type `T` instead.
+       *  Calls to this method are treated specially by the capture checker.
+       */
+      def unsafeAssumePure: T = x
+
       /** If argument is of type `cs T`, converts to type `box cs T`. This
       *  avoids the error that would be raised when boxing `*`.
       */

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

@@ -0,0 +1,4 @@
+class C
+import caps.unsafe.*
+
+def foo(x: C^): C = x.unsafeAssumePure