Drop hasBodyToInline

Merge hasBodyToInline and bodyToInline. This is in preparation to
the state where an erroneous body can suppress inlining by returing an EmptyTree.

Author: odersky

compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala

@@ -590,16 +590,16 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
 
   def apiAnnotations(s: Symbol): List[api.Annotation] = {
     val annots = new mutable.ListBuffer[api.Annotation]
-
-    if (Inliner.hasBodyToInline(s)) {
+    val inlineBody = Inliner.bodyToInline(s)
+    if (!inlineBody.isEmpty) {
       // FIXME: If the body of an inlineable method changes, all the reverse
       // dependencies of this method need to be recompiled. sbt has no way
       // of tracking method bodies, so as a hack we include the pretty-printed
       // typed tree of the method as part of the signature we send to sbt.
       // To do this properly we would need a way to hash trees and types in
       // dotty itself.
       val printTypesCtx = ctx.fresh.setSetting(ctx.settings.XprintTypes, true)
-      annots += marker(Inliner.bodyToInline(s).show(printTypesCtx))
+      annots += marker(inlineBody.show(printTypesCtx))
     }
 
     // In the Scala2 ExtractAPI phase we only extract annotations that extend

compiler/src/dotty/tools/dotc/typer/Inliner.scala

@@ -41,7 +41,10 @@ object Inliner {
    *  @pre  hasBodyToInline(sym)
    */
   def bodyToInline(sym: SymDenotation)(implicit ctx: Context): Tree =
-    sym.unforcedAnnotation(defn.BodyAnnot).get.tree
+    if (sym.isInlineMethod && sym.hasAnnotation(defn.BodyAnnot))
+      sym.getAnnotation(defn.BodyAnnot).get.tree
+    else
+      EmptyTree
 
   /** Should call to method `meth` be inlined in this context? */
   def isInlineable(meth: Symbol)(implicit ctx: Context): Boolean =

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2185,7 +2185,7 @@ class Typer extends Namer
             traverse(xtree :: rest)
           case none =>
             typed(mdef) match {
-              case mdef1: DefDef if Inliner.hasBodyToInline(mdef1.symbol) =>
+              case mdef1: DefDef if !Inliner.bodyToInline(mdef1.symbol).isEmpty =>
                 buf += inlineExpansion(mdef1)
                   // replace body with expansion, because it will be used as inlined body
                   // from separately compiled files - the original BodyAnnotation is not kept.