Transformation class + some separation checking fixes

Author: 05st

scala2-library-cc/src/scala/concurrent/ExecutionContext.scala

@@ -17,6 +17,7 @@ import scala.annotation.implicitNotFound
 
 import language.experimental.captureChecking
 import caps.Capability
+import caps.consume
 
 /**
  * An `ExecutionContext` can execute program logic asynchronously,
@@ -255,7 +256,7 @@ object ExecutionContext {
    *  @param reporter  a function for error reporting
    *  @return          the `ExecutionContext` using the given `ExecutorService`
    */
-  def fromExecutorService(e: ExecutorService, reporter: Throwable => Unit): ExecutionContextExecutorService^{reporter} =
+  def fromExecutorService(e: ExecutorService, @consume reporter: Throwable => Unit): ExecutionContextExecutorService^{reporter} =
     impl.ExecutionContextImpl.fromExecutorService(e, reporter)
 
   /** Creates an `ExecutionContext` from the given `ExecutorService` with the [[scala.concurrent.ExecutionContext$.defaultReporter default reporter]].
@@ -279,7 +280,7 @@ object ExecutionContext {
    *  @param reporter  a function for error reporting
    *  @return          the `ExecutionContext` using the given `Executor`
    */
-  def fromExecutor(e: Executor, reporter: Throwable => Unit): ExecutionContextExecutor^{reporter} =
+  def fromExecutor(e: Executor, @consume reporter: Throwable => Unit): ExecutionContextExecutor^ =
     impl.ExecutionContextImpl.fromExecutor(e, reporter)
 
   /** Creates an `ExecutionContext` from the given `Executor` with the [[scala.concurrent.ExecutionContext$.defaultReporter default reporter]].

scala2-library-cc/src/scala/concurrent/Future.scala

@@ -25,6 +25,7 @@ import scala.reflect.ClassTag
 import scala.concurrent.ExecutionContext.parasitic
 
 import language.experimental.captureChecking
+import caps.consume
 
 /** A `Future` represents a value which may or may not be currently available,
  *  but will be available at some point, or an exception if that value could not be made available.
@@ -424,7 +425,7 @@ trait Future[+T] extends Awaitable[T] {
    * @return        a `Future` with the result of the application of `f` to the results of `this` and `that`
    * @group Transformations
    */
-  def zipWith[U, R](that: Future[U])(f: (T, U) => R)(implicit executor: ExecutionContext): Future[R] = {
+  def zipWith[U, R](that: Future[U])(@consume f: (T, U) => R)(implicit executor: ExecutionContext): Future[R] = {
     // This is typically overriden by the implementation in DefaultPromise, which provides
     // symmetric fail-fast behavior regardless of which future fails first.
     //
@@ -573,7 +574,7 @@ object Future {
   private[concurrent] final val recoverWithFailed = (t: Throwable) => recoverWithFailedMarker
 
   private[this] final val _zipWithTuple2: (Any, Any) => (Any, Any) = Tuple2.apply _
-  private[concurrent] final def zipWithTuple2Fun[T,U] = _zipWithTuple2.asInstanceOf[(T,U) => (T,U)]
+  private[concurrent] final def zipWithTuple2Fun[T,U] = _zipWithTuple2.asInstanceOf //[(T,U) => (T,U)]
 
   private[this] final val _addToBuilderFun: (Builder[Any, Nothing], Any) => Builder[Any, Nothing] = (b: Builder[Any, Nothing], e: Any) => b += e
   private[concurrent] final def addToBuilderFun[A, M] =  _addToBuilderFun.asInstanceOf[Function2[Builder[A, M], A, Builder[A, M]]]
@@ -633,7 +634,7 @@ object Future {
     override final def recover[U >: Nothing](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U] = this
     override final def recoverWith[U >: Nothing](pf: PartialFunction[Throwable, Future[U]])(implicit executor: ExecutionContext): Future[U] = this
     override final def zip[U](that: Future[U]): Future[(Nothing, U)] = this
-    override final def zipWith[U, R](that: Future[U])(f: (Nothing, U) => R)(implicit executor: ExecutionContext): Future[R] = this
+    override final def zipWith[U, R](that: Future[U])(@consume f: (Nothing, U) => R)(implicit executor: ExecutionContext): Future[R] = this
     override final def fallbackTo[U >: Nothing](that: Future[U]): Future[U] = this
     override final def mapTo[S](implicit tag: ClassTag[S]): Future[S] = this
     override final def andThen[U](pf: PartialFunction[Try[Nothing], U])(implicit executor: ExecutionContext): Future[Nothing] = this
@@ -877,4 +878,3 @@ object Future {
 trait OnCompleteRunnable extends Batchable {
   self: Runnable =>
 }
-

scala2-library-cc/src/scala/concurrent/impl/ExecutionContextImpl.scala

@@ -17,6 +17,7 @@ import java.util.Collection
 import scala.concurrent.{ BlockContext, ExecutionContext, CanAwait, ExecutionContextExecutor, ExecutionContextExecutorService }
 
 import language.experimental.captureChecking
+import caps.consume
 
 private[scala] class ExecutionContextImpl private[impl] (final val executor: Executor, final val reporter: Throwable => Unit) extends ExecutionContextExecutor {
   require(executor ne null, "Executor must not be null")
@@ -82,7 +83,7 @@ private[concurrent] object ExecutionContextImpl {
       })
   }
 
-  def createDefaultExecutorService(reporter: Throwable => Unit): ExecutionContextExecutorService^ = {
+  def createDefaultExecutorService(@consume reporter: Throwable => Unit): ExecutionContextExecutorService^ = {
     def getInt(name: String, default: String) = (try System.getProperty(name, default) catch {
       case e: SecurityException => default
     }) match {
@@ -112,13 +113,13 @@ private[concurrent] object ExecutionContextImpl {
     }
   }
 
-  def fromExecutor(e: Executor, reporter: Throwable => Unit = ExecutionContext.defaultReporter): ExecutionContextExecutor^ =
+  def fromExecutor(e: Executor, @consume reporter: Throwable => Unit = ExecutionContext.defaultReporter): ExecutionContextExecutor^ =
     e match {
       case null => createDefaultExecutorService(reporter)
       case some => new ExecutionContextImpl(some, reporter)
     }
 
-  def fromExecutorService(es: ExecutorService, reporter: Throwable => Unit = ExecutionContext.defaultReporter):
+  def fromExecutorService(es: ExecutorService, @consume reporter: Throwable => Unit = ExecutionContext.defaultReporter):
     ExecutionContextExecutorService^ = es match {
       case null => createDefaultExecutorService(reporter)
       case some =>

scala2-library-cc/src/scala/concurrent/impl/Promise.scala

@@ -24,6 +24,9 @@ import java.util.Objects.requireNonNull
 import java.io.{IOException, NotSerializableException, ObjectInputStream, ObjectOutputStream}
 
 import language.experimental.captureChecking
+import scala.annotation.unchecked.uncheckedCaptures
+import caps.cap
+import caps.consume
 import caps.unsafe.*
 
 /**
@@ -66,15 +69,15 @@ private[concurrent] object Promise {
     /**
      * Compresses this chain and returns the currently known root of this chain of Links.
      **/
-    final def promise(owner: DefaultPromise[T]^): DefaultPromise[T]^{this, to, owner} = {
+    final def promise(owner: DefaultPromise[T]^): DefaultPromise[T]^{cap.rd, this, to, owner} = {
       val c = get()
       compressed(current = c, target = c, owner = owner)
     }
 
     /**
      * The combination of traversing and possibly unlinking of a given `target` DefaultPromise.
      **/
-    @inline @tailrec private[this] final def compressed(current: DefaultPromise[T]^, target: DefaultPromise[T]^, owner: DefaultPromise[T]^): DefaultPromise[T]^{this, current, target, owner} = {
+    @inline @tailrec private[this] final def compressed(current: DefaultPromise[T]^{cap.rd, this}, target: DefaultPromise[T]^, owner: DefaultPromise[T]^): DefaultPromise[T]^{this, current, target, owner} = {
       val value = target.get()
       if (value.isInstanceOf[Callbacks[_]]) {
         if (compareAndSet(current, target)) target // Link
@@ -127,6 +130,7 @@ private[concurrent] object Promise {
     /**
      * Returns the associated `Future` with this `Promise`
      */
+    @consume
     override final def future: Future[T]^ = (this : Future[T]^)
 
     override final def transform[S](f: Try[T] => Try[S])(implicit executor: ExecutionContext): Future[S] =
@@ -135,7 +139,7 @@ private[concurrent] object Promise {
     override final def transformWith[S](f: Try[T] => Future[S])(implicit executor: ExecutionContext): Future[S] =
       dispatchOrAddCallbacks(get(), new Transformation[T, S](Xform_transformWith, f, executor))
 
-    override final def zipWith[U, R](that: Future[U])(f: (T, U) => R)(implicit executor: ExecutionContext): Future[R] = {
+    override final def zipWith[U, R](that: Future[U])(@consume f: (T, U) => R)(implicit executor: ExecutionContext): Future[R] = {
       val state = get()
       if (state.isInstanceOf[Try[_]]) {
         if (state.asInstanceOf[Try[T]].isFailure) this.asInstanceOf[Future[R]]
@@ -414,11 +418,14 @@ private[concurrent] object Promise {
    * function's type parameters are erased, and the _xform tag will be used to reify them.
    **/
   final class Transformation[-F, T] private[this] (
-    private[this] final val _fun: Any => Any,
-    private[this] final val _ec: ExecutionContext,
+    __fun: Any => Any,
+    __ec: ExecutionContext,
     private[this] final var _arg: Try[F],
     private[this] final val _xform: Int
   ) extends DefaultPromise[T]() with Callbacks[F] with Runnable with Batchable {
+    @uncheckedCaptures private[this] final var _fun: Any => Any = __fun
+    @uncheckedCaptures private[this] final var _ec: ExecutionContext = __ec
+    
     final def this(xform: Int, f: _ => _, ec: ExecutionContext) =
       this(f.asInstanceOf[Any => Any], ec.prepare(): @nowarn("cat=deprecation"), null, xform)
 
@@ -434,9 +441,9 @@ private[concurrent] object Promise {
       try e.execute(this.unsafeAssumePure) /* Safe publication of _arg, _fun, _ec */
       catch {
         case t: Throwable =>
-          // _fun = null // allow to GC
+          _fun = null // allow to GC
           _arg = null // see above
-          // _ec  = null // see above again
+          _ec  = null // see above again
           handleFailure(t, e)
       }
 
@@ -460,9 +467,9 @@ private[concurrent] object Promise {
       val v   = _arg
       val fun = _fun
       val ec  = _ec
-      // _fun = null // allow to GC
+      _fun = null // allow to GC
       _arg = null // see above
-      // _ec  = null // see above
+      _ec  = null // see above
       try {
         val resolvedResult: Try[_] =
           (_xform: @switch) match {