Abstract from Try in onComplete of FutureSystem#Ops

Adds `Result[A]` type member to `FutureSystem` and
`def resultType[A]` to `FutureSystem#Ops`.

3 files changed, 11 insertions, 5 deletions

diff --git a/src/main/scala/scala/async/Async.scala b/src/main/scala/scala/async/Async.scala
index 35d3687..1cfae1b 100644
--- a/src/main/scala/scala/async/Async.scala
+++ b/src/main/scala/scala/async/Async.scala
@@ -108,7 +108,7 @@ abstract class AsyncBase {
 
     val onCompleteHandler = {
       Function(
-        List(ValDef(Modifiers(Flag.PARAM), name.tr, TypeTree(defn.TryAnyType), EmptyTree)),
+        List(ValDef(Modifiers(Flag.PARAM), name.tr, TypeTree(futureSystemOps.resultType[Any]), EmptyTree)),
         asyncBlock.onCompleteHandler)
     }
     val resumeFunTree = asyncBlock.resumeFunTree[T]
@@ -121,14 +121,14 @@ abstract class AsyncBase {
         val result = ValDef(NoMods, name.result, TypeTree(futureSystemOps.promType[T]), futureSystemOps.createProm[T].tree)
         val execContext = ValDef(NoMods, name.execContext, TypeTree(), futureSystemOps.execContext.tree)
         val applyDefDef: DefDef = {
-          val applyVParamss = List(List(ValDef(Modifiers(Flag.PARAM), name.tr, TypeTree(defn.TryAnyType), EmptyTree)))
+          val applyVParamss = List(List(ValDef(Modifiers(Flag.PARAM), name.tr, TypeTree(futureSystemOps.resultType[Any]), EmptyTree)))
           val applyBody = asyncBlock.onCompleteHandler
           DefDef(NoMods, name.apply, Nil, applyVParamss, TypeTree(definitions.UnitTpe), applyBody)
         }
         val apply0DefDef: DefDef = {
           // We extend () => Unit so we can pass this class as the by-name argument to `Future.apply`.
           // See SI-1247 for the the optimization that avoids creatio
-          val applyVParamss = List(List(ValDef(Modifiers(Flag.PARAM), name.tr, TypeTree(defn.TryAnyType), EmptyTree)))
+          val applyVParamss = List(List(ValDef(Modifiers(Flag.PARAM), name.tr, TypeTree(futureSystemOps.resultType[Any]), EmptyTree)))
           val applyBody = asyncBlock.onCompleteHandler
           DefDef(NoMods, name.apply, Nil, Nil, TypeTree(definitions.UnitTpe), Apply(Ident(name.resume), Nil))
         }
diff --git a/src/main/scala/scala/async/FutureSystem.scala b/src/main/scala/scala/async/FutureSystem.scala
index 8230a0e..5dc04a7 100644
--- a/src/main/scala/scala/async/FutureSystem.scala
+++ b/src/main/scala/scala/async/FutureSystem.scala
@@ -22,6 +22,8 @@ trait FutureSystem {
   type Prom[A]
   /** A (potentially in-progress) computation */
   type Fut[A]
+  /** Result of an asynchronous computation */
+  type Result[A]
   /** An execution context, required to create or register an on completion callback on a Future. */
   type ExecContext
 
@@ -34,6 +36,7 @@ trait FutureSystem {
     def execContext: Expr[ExecContext]
 
     def promType[A: WeakTypeTag]: Type
+    def resultType[A: WeakTypeTag]: Type
     def execContextType: Type
 
     /** Create an empty promise */
@@ -46,7 +49,7 @@ trait FutureSystem {
     def future[A: WeakTypeTag](a: Expr[A])(execContext: Expr[ExecContext]): Expr[Fut[A]]
 
     /** Register an call back to run on completion of the given future */
-    def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[scala.util.Try[A] => U],
+    def onComplete[A, U](future: Expr[Fut[A]], fun: Expr[Result[A] => U],
                          execContext: Expr[ExecContext]): Expr[Unit]
 
     /** Complete a promise with a value */
@@ -75,9 +78,13 @@ trait FutureSystem {
 
 trait TryBasedFutureSystem extends FutureSystem {
 
+  type Result[A] = scala.util.Try[A]
+
   trait OpsWithTry extends Ops {
     import c.universe._
 
+    def resultType[A: WeakTypeTag]: Type = c.weakTypeOf[scala.util.Try[A]]
+
     protected def completePromWithTry[A: WeakTypeTag](prom: Expr[Prom[A]], value: Expr[scala.util.Try[A]]): Expr[Unit]
 
     def completeProm[A: WeakTypeTag](prom: Expr[Prom[A]], value: Expr[A]): Expr[Unit] =
diff --git a/src/main/scala/scala/async/TransformUtils.scala b/src/main/scala/scala/async/TransformUtils.scala
index d6f2643..39847dc 100644
--- a/src/main/scala/scala/async/TransformUtils.scala
+++ b/src/main/scala/scala/async/TransformUtils.scala
@@ -187,7 +187,6 @@ private[async] final case class TransformUtils[C <: Context](c: C) {
     }
 
     val TryClass      = c.mirror.staticClass("scala.util.Try")
-    val TryAnyType    = appliedType(TryClass.toType, List(definitions.AnyTpe))
     val NonFatalClass = c.mirror.staticModule("scala.util.control.NonFatal")
 
     private def asyncMember(name: String) = {