Workaround non-idempotency of typing pattern matching anonymous functions.

 - Undo the transformation that takes place in Typers to
   leave us with Match(EmptyTree, cases).
 - Make sure we don't descend into the cases of such a
   tree when peforming the async transform

1 files changed, 31 insertions, 0 deletions

diff --git a/src/test/scala/scala/async/run/toughtype/ToughType.scala b/src/test/scala/scala/async/run/toughtype/ToughType.scala
index 9cfc1ca..83f5a2d 100644
--- a/src/test/scala/scala/async/run/toughtype/ToughType.scala
+++ b/src/test/scala/scala/async/run/toughtype/ToughType.scala
@@ -36,4 +36,35 @@ class ToughTypeSpec {
     val res: (List[_], scala.async.run.toughtype.ToughTypeObject.Inner) = Await.result(fut, 2 seconds)
     res._1 mustBe (Nil)
   }
+
+  @Test def patternMatchingPartialFunction() {
+    import AsyncId.{await, async}
+    async {
+      await(1)
+      val a = await(1)
+      val f = { case x => x + a }: PartialFunction[Int, Int]
+      await(f(2))
+    } mustBe 3
+  }
+
+  @Test def patternMatchingPartialFunctionNested() {
+    import AsyncId.{await, async}
+    async {
+      await(1)
+      val neg1 = -1
+      val a = await(1)
+      val f = { case x => ({case x => neg1 * x}: PartialFunction[Int, Int])(x + a) }: PartialFunction[Int, Int]
+      await(f(2))
+    } mustBe -3
+  }
+
+  @Test def patternMatchingFunction() {
+    import AsyncId.{await, async}
+    async {
+      await(1)
+      val a = await(1)
+      val f = { case x => x + a }: Function[Int, Int]
+      await(f(2))
+    } mustBe 3
+  }
 }