Drop legacy caps.unsafe operations

Retain only caps.unsafe.unsafeAssumePure

Author: odersky

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

@@ -584,8 +584,6 @@ extension (sym: Symbol)
       case _ => false
     containsEnclTypeParam(sym.info.finalResultType)
     && !sym.allowsRootCapture
-    && sym != defn.Caps_unsafeBox
-    && sym != defn.Caps_unsafeUnbox
     && !defn.isPolymorphicAfterErasure(sym)
     && !defn.isTypeTestOrCast(sym)
 

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

@@ -607,13 +607,6 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  otherwise return NoType.
      */
     private def recheckUnsafeApply(tree: Apply, pt: Type)(using Context): Type =
-
-      def mapArgUsing(f: Type => Type) =
-        val arg :: Nil = tree.args: @unchecked
-        val argType0 = f(recheckStart(arg, pt))
-        val argType = super.recheckFinish(argType0, arg, pt)
-        super.recheckFinish(argType, tree, pt)
-
       val meth = tree.fun.symbol
       if meth == defn.Caps_unsafeAssumePure then
         val arg :: Nil = tree.args: @unchecked
@@ -623,31 +616,25 @@ class CheckCaptures extends Recheck, SymTransformer:
           else argType0.widen.stripCapturing
         capt.println(i"rechecking $arg with $pt: $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))
-      else if meth == defn.Caps_unsafeBoxFunArg then
-        def forceBox(tp: Type): Type = tp.strippedDealias match
-          case defn.FunctionOf(paramtpe :: Nil, restpe, isContextual) =>
-            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContextual)
-          case tp @ RefinedType(parent, rname, rinfo: MethodType) =>
-            tp.derivedRefinedType(parent, rname,
-              rinfo.derivedLambdaType(
-                paramInfos = rinfo.paramInfos.map(_.forceBoxStatus(true))))
-          case tp @ CapturingType(parent, refs) =>
-            tp.derivedCapturingType(forceBox(parent), refs)
-        mapArgUsing(forceBox)
       else NoType
     end recheckUnsafeApply
 
-    /** Recheck applications. More work is done in `recheckApplication`,
-     *  `recheckArg` and `instantiate` below.
+    /** Recheck applications, with special handling of unsafeAssumePure.
+     *  More work is done in `recheckApplication`, `recheckArg` and `instantiate` below.
      */
     override def recheckApply(tree: Apply, pt: Type)(using Context): Type =
-      recheckUnsafeApply(tree, pt).orElse:
+      val meth = tree.fun.symbol
+      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: $argType")
+        super.recheckFinish(argType, tree, pt)
+      else
         val res = super.recheckApply(tree, pt)
-        includeCallCaptures(tree.symbol, res, tree.srcPos)
+        includeCallCaptures(meth, res, tree.srcPos)
         res
 
     /** Recheck argument, and, if formal parameter carries a `@use`,

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

@@ -999,9 +999,6 @@ class Definitions {
     @tu lazy val Caps_Exists: ClassSymbol = requiredClass("scala.caps.Exists")
     @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")
     @tu lazy val Caps_ContainsTrait: TypeSymbol = CapsModule.requiredType("Contains")
     @tu lazy val Caps_containsImpl: TermSymbol = CapsModule.requiredMethod("containsImpl")
 

library/src/scala/caps.scala

@@ -66,20 +66,4 @@ import annotation.{experimental, compileTimeOnly, retainsCap}
        */
       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 `cap`.
-      */
-      def unsafeBox: 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 `cap`.
-       */
-      def unsafeUnbox: T = x
-
-    extension [T, U](f: T => U)
-      /** If argument is of type `box cs T`, converts to type `cs T`. This
-       *  avoids the error that would be raised when unboxing `cap`.
-       */
-      def unsafeBoxFunArg: T => U = f
-
   end unsafe