New escape hatch: discardUses

Author: odersky

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

@@ -87,6 +87,8 @@ class CCState:
 
   private var collapseFresh: Boolean = false
 
+  private var discardUses: Boolean = false
+
 object CCState:
 
   /** If we are currently in capture checking or setup, and `mt` is a method
@@ -137,4 +139,16 @@ object CCState:
   /** Should all FreshCap instances be treated as equal to GlobalCap? */
   def collapseFresh(using Context): Boolean = ccState.collapseFresh
 
+  /** Run `op` but suppress all recording of uses in `markFree` */
+   inline def withDiscardedUses[T](op: => T)(using Context): T =
+    if isCaptureCheckingOrSetup then
+      val ccs = ccState
+      val saved = ccs.discardUses
+      ccs.discardUses = true
+      try op finally ccs.discardUses = saved
+    else op
+
+  /** Should uses not be recorded in markFree? */
+  def discardUses(using Context): Boolean = ccState.discardUses
+
 end CCState

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

@@ -574,7 +574,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           	// Under deferredReaches, don't propagate out of methods inside terms.
           	// The use set of these methods will be charged when that method is called.
 
-      if !cs.isAlwaysEmpty then
+      if !cs.isAlwaysEmpty && !CCState.discardUses then
         recur(cs, curEnv, null)
         if addUseInfo then useInfos += ((tree, cs, curEnv))
     end markFree
@@ -783,6 +783,9 @@ class CheckCaptures extends Recheck, SymTransformer:
           else argType0.widen.stripCapturing
         capt.println(i"rechecking unsafeAssumePure of $arg with $pt: $argType")
         super.recheckFinish(argType, tree, pt)
+      else if meth == defn.Caps_unsafeDiscardUses then
+        val arg :: Nil = tree.args: @unchecked
+        withDiscardedUses(recheck(arg, pt))
       else
         val res = super.recheckApply(tree, pt)
         includeCallCaptures(meth, res, tree)

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

@@ -1026,6 +1026,7 @@ class Definitions {
     @tu lazy val CapsUnsafeModule: Symbol = requiredModule("scala.caps.unsafe")
     @tu lazy val Caps_unsafeAssumePure: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumePure")
     @tu lazy val Caps_unsafeAssumeSeparate: Symbol = CapsUnsafeModule.requiredMethod("unsafeAssumeSeparate")
+    @tu lazy val Caps_unsafeDiscardUses: Symbol = CapsUnsafeModule.requiredMethod("unsafeDiscardUses")
     @tu lazy val Caps_unsafeErasedValue: Symbol = CapsUnsafeModule.requiredMethod("unsafeErasedValue")
     @tu lazy val Caps_ContainsTrait: TypeSymbol = CapsModule.requiredType("Contains")
     @tu lazy val Caps_ContainsModule: Symbol = requiredModule("scala.caps.Contains")

library/src/scala/caps/package.scala

@@ -208,6 +208,9 @@ object unsafe:
    */
   def unsafeAssumeSeparate(op: Any): op.type = op
 
+  /** A wrapper around code for which uses go unrecorded */
+  def unsafeDiscardUses(op: Any): op.type = op
+
   /** An unsafe variant of erasedValue that can be used as an escape hatch. Unlike the
    *  user-accessible compiletime.erasedValue, this version is assumed
    *  to be a pure expression, hence capability safe. But there is no proof

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

@@ -0,0 +1,2 @@
+def test(c: Object^) =
+  val x: () -> Unit = caps.unsafe.unsafeDiscardUses(() => println(c))