Fixed bug with calls in tail position with fina...

Fixed bug with calls in tail position with final handlers.

2 files changed, 43 insertions, 0 deletions

diff --git a/test/files/run/tailcalls.check b/test/files/run/tailcalls.check
index 73d86cd2d2..83ea0b3760 100644
--- a/test/files/run/tailcalls.check
+++ b/test/files/run/tailcalls.check
@@ -39,8 +39,12 @@ test c.c.c.c.f was successful
 test TailCall.f1 was successful
 test TailCall.f2 was successful
 test TailCall.f3 was successful
+test TailCall.f4 was successful
 test TailCall.g1 was successful
 test TailCall.g2 was successful
 test TailCall.g3 was successful
 test TailCall.h1 was successful
 
+test NonTailCall.f1 0 1 2 was successful
+test NonTailCall.f2 was successful
+
diff --git a/test/files/run/tailcalls.scala b/test/files/run/tailcalls.scala
index 037b8b41f8..b20fbb20f4 100644
--- a/test/files/run/tailcalls.scala
+++ b/test/files/run/tailcalls.scala
@@ -158,6 +158,11 @@ class TailCall[S](s: S) {
     if (n == 0) v else f2[T](n - 1, v - 1);
   final def f3[T](n: Int, v: Int, ls: List[T]): Int =
     if (n == 0) v else f3(n - 1, v - 1, ls);
+  final def f4(n: Int, v: Int): Int = try {
+    if (n == 0) v else f4(n - 1, v - 1);
+  } catch {
+    case e: Throwable => throw e
+  }
 
   final def g1(x: Int, y: Int): Int = {
     def aux(n: Int, v: Int): Int =
@@ -184,6 +189,22 @@ class TailCall[S](s: S) {
 
 }
 
+
+class NonTailCall {
+  final def f1(n: Int): Int = try {
+    if (n == 0) 0
+    else f1(n - 1)
+  } finally {
+    Console.print(" " + n)
+  }
+
+  final def f2(n: Int): Int = synchronized {
+    if (n == 0) 0
+    else f2(n - 1)
+  }
+
+}
+
 //############################################################################
 // Test code
 
@@ -205,6 +226,19 @@ object Test {
     Console.println;
   }
 
+  def check_overflow(name: String, closure: => Int): Unit = {
+    Console.print("test " + name);
+    try {
+      val actual: Int = closure;
+    } catch {
+      case exception: compat.Platform.StackOverflowError => Console.println(" was successful");
+      case exception: Throwable => {
+        Console.print(" raised exception " + exception);
+      }
+    }
+    Console.println;
+  }
+
   def calibrate: Int = {
     val calibrator = new Calibrator();
     var stop = false;
@@ -279,11 +313,16 @@ object Test {
     check_success("TailCall.f1", TailCall.f1(max, max     ), 0);
     check_success("TailCall.f2", TailCall.f2(max, max     ), 0);
     check_success("TailCall.f3", TailCall.f3(max, max, Nil), 0);
+    check_success("TailCall.f4", TailCall.f4(max, max     ), 0);
     check_success("TailCall.g1", TailCall.g1(max, max     ), 0);
     check_success("TailCall.g2", TailCall.g2(max, max     ), 0);
     check_success("TailCall.g3", TailCall.g3(max, max, Nil), 0);
     check_success("TailCall.h1", TailCall.h1(max, max     ), 0);
     Console.println;
+
+    val NonTailCall = new NonTailCall;
+    check_success("NonTailCall.f1", NonTailCall.f1(2), 0)
+    check_overflow("NonTailCall.f2", NonTailCall.f2(max))
   }
 }