Move TailRec after Erasure.

This used not to be possible because it was too complicated for
TailRec to understand trees produced by the pattern matcher. Now
that patmat uses `Labeled` blocks instead of label-defs, it is
trivial to do so: the argument of a `return` from a labeled block
`lab` is in tail position if and only if the labeled block `lab` is
itself in tail position.

Running TailRec after erasure has two major benefits:

* it is much simpler, as it does not have to deal with type
  parameters, `TypeApply`s, and a bunch of other stuff.
* it supports polymorphic tail-recursive calls by construction
  (recursive calls whose receiver or method has different type
  parameters).

It also has one difficulty: it cannot see the *call-site*
`@tailrec` annotations anymore. This is why we add a mini-phase to
record such annotations as tree attachments.

Having TailRec after erasure will also be necessary to later make
it use `Labeled` blocks and loops instead of label-defs itself.
Indeed, in that case it will need to declare local `var`s for its
term parameters, which would break path-dependent types within the
method if it were done before erasure.

Author: sjrd

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

@@ -67,7 +67,6 @@ class Compiler {
          new ProtectedAccessors,     // Add accessors for protected members
          new ExtensionMethods,       // Expand methods of value classes with extension methods
          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
          new HoistSuperArgs,         // Hoist complex arguments of supercalls to enclosing scope
@@ -92,10 +91,12 @@ class Compiler {
          new ResolveSuper,           // Implement super accessors and add forwarders to trait methods
          new PrimitiveForwarders,    // Add forwarders to trait methods that have a mismatch between generic and primitives
          new FunctionXXLForwarders,  // Add forwarders for FunctionXXL apply method
+         new RecordTailRecCallSites, // Records call-site @tailrec annotations as attachments
          new ArrayConstructors) ::   // Intercept creation of (non-generic) arrays and intrinsify.
     List(new Erasure) ::             // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
     List(new ElimErasedValueType,    // Expand erased value types to their underlying implmementation types
          new VCElideAllocations,     // Peep-hole optimization to eliminate unnecessary value class allocations
+         new TailRec,                // Rewrite tail recursion to loops
          new Mixin,                  // Expand trait fields and trait initializers
          new LazyVals,               // Expand lazy vals
          new Memoize,                // Add private fields to getters and setters

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -116,6 +116,11 @@ class TreeTypeMap(
           val guard1 = tmap.transform(guard)
           val rhs1 = tmap.transform(rhs)
           cpy.CaseDef(cdef)(pat1, guard1, rhs1)
+        case labeled @ Labeled(bind, expr) =>
+          val tmap = withMappedSyms(bind.symbol :: Nil)
+          val bind1 = tmap.transformSub(bind)
+          val expr1 = tmap.transform(expr)
+          cpy.Labeled(labeled)(bind1, expr1)
         case Hole(n, args) =>
           Hole(n, args.mapConserve(transform)).withPos(tree.pos).withType(mapType(tree.tpe))
         case tree1 =>

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

@@ -24,7 +24,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
       name = member.name.stripScala2LocalSuffix,
       flags = member.flags &~ Deferred,
       info = cls.thisType.memberInfo(member)).enteredAfter(thisPhase).asTerm
-    res.addAnnotations(member.annotations)
+    res.addAnnotations(member.annotations.filter(_.symbol != defn.TailrecAnnot))
     res
   }
 

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

@@ -27,7 +27,6 @@ class PatternMatcher extends MiniPhase {
 
   override def phaseName = PatternMatcher.name
   override def runsAfter = Set(ElimRepeated.name)
-  override def runsAfterGroupsOf = Set(TailRec.name) // tailrec is not capable of reversing the patmat tranformation made for tree
 
   override def transformMatch(tree: Match)(implicit ctx: Context): Tree = {
     val translated = new Translator(tree.tpe, this).translateMatch(tree)

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

@@ -0,0 +1,42 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import MegaPhase._
+import Contexts.Context
+import Flags._
+import SymUtils._
+import Symbols._
+import SymDenotations._
+import Types._
+import Decorators._
+import DenotTransformers._
+import StdNames._
+import NameOps._
+import ast.Trees._
+import dotty.tools.dotc.ast.tpd
+import util.Positions._
+import Names._
+
+import collection.mutable
+import ResolveSuper._
+
+import scala.collection.immutable.::
+
+
+/** This phase saves call-site `@tailrec` annotations as attachments.
+ *
+ *  Since erasure will come before the `tailrec` phase, it will erase the `@tailrec` annotations
+ *  in the `Typed` nodes.
+ */
+class RecordTailRecCallSites extends MiniPhase {
+  import ast.tpd._
+
+  override def phaseName: String = "recordTailrecCallSites"
+
+  override def transformTyped(tree: Typed)(implicit ctx: Context): Tree = {
+    if (tree.tpt.tpe.hasAnnotation(defn.TailrecAnnot) && tree.expr.isInstanceOf[Apply])
+      tree.expr.pushAttachment(TailRec.TailRecCallSiteKey, ())
+    super.transformTyped(tree)
+  }
+}