A pretty severe bug in the recognition of tail ...

A pretty severe bug in the recognition of tail call elimination.
It turns out that Tailcalls will perform "partial elimination" in
situations such as:

  @annotation.tailrec final def f(x: Int): Int = f(f(x))

The outer call to f1 becomes a jump, but the inner call remains as
it was. I implemented @tailrec under the impression that if the
optimization had taken place, it had gone all the way. So this is now
fixed with a direct examination of the rewritten tree.

While I was in there I threw in some improved error reporting: the error
positioning is now on the call which is not in tail position rather than
the method declaration.

Closes #4135, no review.

1 files changed, 10 insertions, 0 deletions

diff --git a/test/files/neg/tailrec-3.check b/test/files/neg/tailrec-3.check
new file mode 100644
index 0000000000..a3542fb564
--- /dev/null
+++ b/test/files/neg/tailrec-3.check
@@ -0,0 +1,10 @@
+tailrec-3.scala:4: error: could not optimize @tailrec annotated method quux: it contains a recursive call not in tail position
+  @tailrec private def quux(xs: List[String]): List[String] = quux(quux(xs))
+                                                                       ^
+tailrec-3.scala:6: error: could not optimize @tailrec annotated method quux2: it contains a recursive call not in tail position
+    case x1 :: x2 :: rest => quux2(x1 :: quux2(rest))
+                                              ^
+tailrec-3.scala:10: error: could not optimize @tailrec annotated method quux3: it contains a recursive call not in tail position
+    case x :: xs if quux3(List("abc"))  => quux3(xs)
+                         ^
+three errors found