Introduce @forceInline annotation

An annotation on methods that is equivalent to Dotty `inline` modifier.
The annotation should be used instead of the `inline` modifier in code
that needs to cross compile between Scala 2 and Dotty.

Author: allanrenucci

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

@@ -1052,7 +1052,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def enclosingInlineds(implicit ctx: Context): List[Tree] =
     ctx.property(InlinedCalls).getOrElse(Nil)
 
-  /** The source file where the symbol of the `@inline` method referred to by `call`
+  /** The source file where the symbol of the `inline` method referred to by `call`
    *  is defined
    */
   def sourceFile(call: Tree)(implicit ctx: Context) = {

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

@@ -707,8 +707,8 @@ class Definitions {
   def ImplicitAmbiguousAnnot(implicit ctx: Context) = ImplicitAmbiguousAnnotType.symbol.asClass
   lazy val ImplicitNotFoundAnnotType = ctx.requiredClassRef("scala.annotation.implicitNotFound")
   def ImplicitNotFoundAnnot(implicit ctx: Context) = ImplicitNotFoundAnnotType.symbol.asClass
-  lazy val InlineAnnotType = ctx.requiredClassRef("scala.inline")
-  def InlineAnnot(implicit ctx: Context) = InlineAnnotType.symbol.asClass
+  lazy val ForceInlineAnnotType = ctx.requiredClassRef("scala.forceInline")
+  def ForceInlineAnnot(implicit ctx: Context) = ForceInlineAnnotType.symbol.asClass
   lazy val InlineParamAnnotType = ctx.requiredClassRef("scala.annotation.internal.InlineParam")
   def InlineParamAnnot(implicit ctx: Context) = InlineParamAnnotType.symbol.asClass
   lazy val InvariantBetweenAnnotType = ctx.requiredClassRef("scala.annotation.internal.InvariantBetween")

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

@@ -803,6 +803,6 @@ object Symbols {
     override def toString: String = value.asScala.toString()
   }
 
-  @inline def newMutableSymbolMap[T]: MutableSymbolMap[T] =
+  @forceInline def newMutableSymbolMap[T]: MutableSymbolMap[T] =
     new MutableSymbolMap(new java.util.IdentityHashMap[Symbol, T]())
 }

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

@@ -3935,7 +3935,7 @@ object Types {
   abstract class VariantTraversal {
     protected[core] var variance = 1
 
-    @inline protected def atVariance[T](v: Int)(op: => T): T = {
+    @forceInline protected def atVariance[T](v: Int)(op: => T): T = {
       val saved = variance
       variance = v
       val res = op

compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala

@@ -316,7 +316,7 @@ object MarkupParsers {
     }
 
     /** Some try/catch/finally logic used by xLiteral and xLiteralPattern.  */
-    @inline private def xLiteralCommon(f: () => Tree, ifTruncated: String => Unit): Tree = {
+    @forceInline private def xLiteralCommon(f: () => Tree, ifTruncated: String => Unit): Tree = {
       var output: Tree = null.asInstanceOf[Tree]
       try output = f()
       catch {

compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala

@@ -51,12 +51,12 @@ object SyntaxHighlighting {
     val newBuf     = new StringBuilder
     var lastValDefToken  = ""
 
-    @inline def keywordStart =
+    @forceInline def keywordStart =
       prev == 0    || prev == ' ' || prev == '{' || prev == '(' ||
       prev == '\n' || prev == '[' || prev == ',' || prev == ':' ||
       prev == '|'  || prev == '&'
 
-    @inline def numberStart(c: Char) =
+    @forceInline def numberStart(c: Char) =
       c.isDigit && (!prev.isLetter || prev == '.' || prev == ' ' || prev == '(' || prev == '\u0000')
 
     def takeChar(): Char = takeChars(1).head

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1748,7 +1748,7 @@ object messages {
     val kind = "Syntax"
     val msg = hl"no explicit ${"return"} allowed from inline $owner"
     val explanation =
-      hl"""Methods marked with ${"@inline"} may not use ${"return"} statements.
+      hl"""Methods marked with ${"inline"} modifier may not use ${"return"} statements.
           |Instead, you should rely on the last expression's value being
           |returned from a method.
           |"""

compiler/src/dotty/tools/dotc/reporting/trace.scala

@@ -9,19 +9,19 @@ import core.Mode
 
 object trace {
 
-  @inline
+  @forceInline
   def onDebug[TD](question: => String)(op: => TD)(implicit ctx: Context): TD =
     conditionally(ctx.settings.YdebugTrace.value, question, false)(op)
 
-  @inline
+  @forceInline
   def conditionally[TC](cond: Boolean, question: => String, show: Boolean)(op: => TC)(implicit ctx: Context): TC =
     if (Config.tracingEnabled) {
       def op1 = op
       if (cond) apply[TC](question, Printers.default, show)(op1)
       else op1
     } else op
 
-  @inline
+  @forceInline
   def apply[T](question: => String, printer: Printers.Printer, showOp: Any => String)(op: => T)(implicit ctx: Context): T =
     if (Config.tracingEnabled) {
       def op1 = op
@@ -30,7 +30,7 @@ object trace {
     }
     else op
 
-  @inline
+  @forceInline
   def apply[T](question: => String, printer: Printers.Printer, show: Boolean)(op: => T)(implicit ctx: Context): T =
     if (Config.tracingEnabled) {
       def op1 = op
@@ -39,15 +39,15 @@ object trace {
     }
     else op
 
-  @inline
+  @forceInline
   def apply[T](question: => String, printer: Printers.Printer)(op: => T)(implicit ctx: Context): T =
     apply[T](question, printer, false)(op)
 
-  @inline
+  @forceInline
   def apply[T](question: => String, show: Boolean)(op: => T)(implicit ctx: Context): T =
     apply[T](question, Printers.default, show)(op)
 
-  @inline
+  @forceInline
   def apply[T](question: => String)(op: => T)(implicit ctx: Context): T =
     apply[T](question, Printers.default, false)(op)
 

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

@@ -229,7 +229,7 @@ object Inliner {
   }
 
   /** `sym` has an inline method with a known body to inline (note: definitions coming
-   *  from Scala2x class files might be `@inline`, but still lack that body.
+   *  from Scala2x class files might be `@forceInline`, but still lack that body.
    */
   def hasBodyToInline(sym: SymDenotation)(implicit ctx: Context): Boolean =
     sym.isInlinedMethod && sym.hasAnnotation(defn.BodyAnnot) // TODO: Open this up for transparent methods as well
@@ -240,7 +240,7 @@ object Inliner {
   def bodyToInline(sym: SymDenotation)(implicit ctx: Context): Tree =
     sym.unforcedAnnotation(defn.BodyAnnot).get.tree
 
-  /** Try to inline a call to a `@inline` method. Fail with error if the maximal
+  /** Try to inline a call to a `inline` method. Fail with error if the maximal
    *  inline depth is exceeded.
    *
    *  @param tree   The call to inline
@@ -281,7 +281,7 @@ object Inliner {
 
 /** Produces an inlined version of `call` via its `inlined` method.
  *
- *  @param  call         the original call to a `@inline` method
+ *  @param  call         the original call to an `inline` method
  *  @param  rhsToInline  the body of the inline method that replaces the call.
  */
 class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {

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

@@ -751,7 +751,7 @@ class Namer { typer: Typer =>
       if (sym.unforcedAnnotation(cls).isEmpty) {
         val ann = Annotation.deferred(cls, implicit ctx => typedAheadAnnotation(annotTree))
         sym.addAnnotation(ann)
-        if (cls == defn.InlineAnnot && sym.is(Method, butNot = Accessor))
+        if (cls == defn.ForceInlineAnnot && sym.is(Method, butNot = Accessor))
           sym.setFlag(Inline)
       }
     }