Fix #4196: TailRec-optimize methods returning implicit function types

Before `ShortcutImplicits`, calls to such methods are never in tail
position since we call `.apply` on them to pass the implicit arguments.
By moving `ShortcutImplicits` before `TailRec` we avoid this problem.

Author: smarter

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -67,6 +67,7 @@ class Compiler {
          new NormalizeFlags,         // Rewrite some definition flags
          new ExtensionMethods,       // Expand methods of value classes with extension methods
          new ExpandSAMs,             // Expand single abstract method closures to anonymous classes
+         new ShortcutImplicits,      // Allow implicit functions without creating closures
          new TailRec,                // Rewrite tail recursion to loops
          new ByNameClosures,         // Expand arguments to by-name parameters to closures
          new LiftTry,                // Put try expressions that might execute on non-empty stacks into their own methods
@@ -77,7 +78,6 @@ class Compiler {
          new PatternMatcher,         // Compile pattern matches
          new ExplicitOuter,          // Add accessors to outer classes from nested ones.
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
-         new ShortcutImplicits,      // Allow implicit functions without creating closures
          new CrossCastAnd,           // Normalize selections involving intersection types.
          new Splitter) ::            // Expand selections involving union types into conditionals
     List(new ErasedDecls,            // Removes all erased defs and vals decls (except for parameters)

compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala

@@ -138,6 +138,14 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPh
     if (shouldBeSpecialized(original)) {
       val direct = directMethod(original)
 
+      // Move @tailrec to the direct method
+      original.getAnnotation(defn.TailrecAnnot) match {
+        case Some(annot) =>
+          direct.addAnnotation(annot)
+          original.removeAnnotation(defn.TailrecAnnot)
+        case _ =>
+      }
+
       def splitClosure(tree: Tree): (List[Type] => List[List[Tree]] => Tree, Tree) = tree match {
         case Block(Nil, expr) => splitClosure(expr)
         case Block((meth @ DefDef(nme.ANON_FUN, Nil, clparams :: Nil, _, _)) :: Nil, cl: Closure) =>

tests/neg/i4196.scala

@@ -0,0 +1,8 @@
+object Test {
+  @annotation.tailrec
+  def foo(i: implicit Unit => Int): implicit Unit => Int =
+    if (i == 0)
+      0
+    else
+      foo(i - 1)*2 // error: method not tail recursive
+}

tests/pos/i4196.scala

@@ -0,0 +1,8 @@
+object Test {
+  @annotation.tailrec
+  def foo(i: implicit Unit => Int): implicit Unit => Int =
+    if (i == 0)
+      0
+    else
+      foo(i - 1)
+}