Feature Removal: Do not check call-site @tailrec anymore.

This feature does not exist in Scala 2, and was never documented in
Scala 3. Its only internal use comes from a swiping commit that
added as many `@tailrec` annotations as possible all over the
codebase: see be5720c.

Supporting that feature became problematic when TailRec was moved
after erasure, because we needed an attachment to remember
call-site `@tailrec` annotations, which would otherwise be removed
by erasure.

This commit removes the feature, on the grounds that its
cost/benefit is too high.

Author: sjrd

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

@@ -91,7 +91,6 @@ 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

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -208,17 +208,17 @@ object Types {
       def loop(tp: Type): Boolean = tp match {
         case tp: TypeRef =>
           val sym = tp.symbol
-          if (sym.isClass) sym.derivesFrom(cls) else loop(tp.superType): @tailrec
+          if (sym.isClass) sym.derivesFrom(cls) else loop(tp.superType)
         case tp: AppliedType =>
           tp.superType.derivesFrom(cls)
         case tp: MatchType =>
           tp.bound.derivesFrom(cls) || tp.reduced.derivesFrom(cls)
         case tp: TypeProxy =>
-          loop(tp.underlying): @tailrec
+          loop(tp.underlying)
         case tp: AndType =>
-          loop(tp.tp1) || loop(tp.tp2): @tailrec
+          loop(tp.tp1) || loop(tp.tp2)
         case tp: OrType =>
-          loop(tp.tp1) && loop(tp.tp2): @tailrec
+          loop(tp.tp1) && loop(tp.tp2)
         case tp: JavaArrayType =>
           cls == defn.ObjectClass
         case _ =>
@@ -403,16 +403,16 @@ object Types {
      */
     final def classSymbol(implicit ctx: Context): Symbol = this match {
       case ConstantType(constant) =>
-        constant.tpe.classSymbol: @tailrec
+        constant.tpe.classSymbol
       case tp: TypeRef =>
         val sym = tp.symbol
-        if (sym.isClass) sym else tp.superType.classSymbol: @tailrec
+        if (sym.isClass) sym else tp.superType.classSymbol
       case tp: ClassInfo =>
         tp.cls
       case tp: SingletonType =>
         NoSymbol
       case tp: TypeProxy =>
-        tp.underlying.classSymbol: @tailrec
+        tp.underlying.classSymbol
       case AndType(l, r) =>
         val lsym = l.classSymbol
         val rsym = r.classSymbol
@@ -436,9 +436,9 @@ object Types {
         tp.cls :: Nil
       case tp: TypeRef =>
         val sym = tp.symbol
-        if (sym.isClass) sym.asClass :: Nil else tp.superType.classSymbols: @tailrec
+        if (sym.isClass) sym.asClass :: Nil else tp.superType.classSymbols
       case tp: TypeProxy =>
-        tp.underlying.classSymbols: @tailrec
+        tp.underlying.classSymbols
       case AndType(l, r) =>
         l.classSymbols union r.classSymbols
       case OrType(l, r) =>
@@ -479,7 +479,7 @@ object Types {
       case tp: ClassInfo =>
         tp.decls
       case tp: TypeProxy =>
-        tp.underlying.decls: @tailrec
+        tp.underlying.decls
       case _ =>
         EmptyScope
     }
@@ -725,7 +725,7 @@ object Types {
         val ns = tp.parent.memberNames(keepOnly, pre)
         if (keepOnly(pre, tp.refinedName)) ns + tp.refinedName else ns
       case tp: TypeProxy =>
-        tp.underlying.memberNames(keepOnly, pre): @tailrec
+        tp.underlying.memberNames(keepOnly, pre)
       case tp: AndType =>
         tp.tp1.memberNames(keepOnly, pre) | tp.tp2.memberNames(keepOnly, pre)
       case tp: OrType =>
@@ -1042,21 +1042,21 @@ object Types {
       case tp: TypeRef =>
         if (tp.symbol.isClass) tp
         else tp.info match {
-          case TypeAlias(alias) => alias.dealias1(keep): @tailrec
+          case TypeAlias(alias) => alias.dealias1(keep)
           case _ => tp
         }
       case app @ AppliedType(tycon, args) =>
         val tycon1 = tycon.dealias1(keep)
-        if (tycon1 ne tycon) app.superType.dealias1(keep): @tailrec
+        if (tycon1 ne tycon) app.superType.dealias1(keep)
         else this
       case tp: TypeVar =>
         val tp1 = tp.instanceOpt
-        if (tp1.exists) tp1.dealias1(keep): @tailrec else tp
+        if (tp1.exists) tp1.dealias1(keep) else tp
       case tp: AnnotatedType =>
         val tp1 = tp.parent.dealias1(keep)
         if (keep(tp)(ctx)) tp.derivedAnnotatedType(tp1, tp.annot) else tp1
       case tp: LazyRef =>
-        tp.ref.dealias1(keep): @tailrec
+        tp.ref.dealias1(keep)
       case _ => this
     }
 

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

@@ -74,20 +74,6 @@ class TailRec extends MiniPhase {
 
   final val labelFlags = Flags.Synthetic | Flags.Label | Flags.Method
 
-  /** Symbols of methods that have @tailrec annotatios inside */
-  private val methodsWithInnerAnnots = new collection.mutable.HashSet[Symbol]()
-
-  override def transformUnit(tree: Tree)(implicit ctx: Context): Tree = {
-    methodsWithInnerAnnots.clear()
-    tree
-  }
-
-  override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
-    if (tree.getAttachment(TailRecCallSiteKey).isDefined)
-      methodsWithInnerAnnots += ctx.owner.enclosingMethod
-    tree
-  }
-
   private def mkLabel(method: Symbol)(implicit ctx: Context): TermSymbol = {
     val name = TailLabelName.fresh()
 
@@ -181,7 +167,7 @@ class TailRec extends MiniPhase {
             dd.rhs
           }
         })
-      case d: DefDef if d.symbol.hasAnnotation(defn.TailrecAnnot) || methodsWithInnerAnnots.contains(d.symbol) =>
+      case d: DefDef if d.symbol.hasAnnotation(defn.TailrecAnnot) =>
         ctx.error(TailrecNotApplicable(sym), sym.pos)
         d
       case _ => tree
@@ -238,8 +224,7 @@ class TailRec extends MiniPhase {
           Apply(noTailTransform(call), arguments)
 
         def fail(reason: String) = {
-          def required = tree.getAttachment(TailRecCallSiteKey).isDefined
-          if (isMandatory || required) c.error(s"Cannot rewrite recursive call: $reason", tree.pos)
+          if (isMandatory) c.error(s"Cannot rewrite recursive call: $reason", tree.pos)
           else c.debuglog("Cannot rewrite recursive call at: " + tree.pos + " because: " + reason)
           continue
         }
@@ -359,6 +344,4 @@ object TailRec {
 
   final val noTailContext = new TailContext(false)
   final val yesTailContext = new TailContext(true)
-
-  object TailRecCallSiteKey extends Property.StickyKey[Unit]
 }