Switch to implementation scheme described in PR

The previous scheme was more complicated and looks more fragile,
in particular if complex staging operations are applied to a retained
inline method. In that case we have to rely on the fact that the rhs
of a retained inline method is in fact its inlineable body, and not
the retained body.

Author: odersky

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

@@ -353,6 +353,7 @@ object NameKinds {
   val ProtectedAccessorName: PrefixNameKind = new PrefixNameKind(PROTECTEDACCESSOR, "protected$")
   val InlineAccessorName: PrefixNameKind = new PrefixNameKind(INLINEACCESSOR, "inline$")
 
+  val BodyRetainerName: SuffixNameKind = new SuffixNameKind(BODYRETAINER, "$retainedBody")
   val FieldName: SuffixNameKind = new SuffixNameKind(FIELD, "$$local") {
       override def mkString(underlying: TermName, info: ThisInfo) = underlying.toString
   }

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

@@ -938,13 +938,16 @@ object SymDenotations {
     def isInlineMethod(implicit ctx: Context): Boolean =
       isAllOf(InlineMethod, butNot = Accessor)
 
+    def isInlineRetained(using Context): Boolean =
+      !is(Deferred) && allOverriddenSymbols.exists(!_.is(Inline))
+
     /** Is this a Scala 2 macro */
     final def isScala2Macro(implicit ctx: Context): Boolean = is(Macro) && symbol.owner.is(Scala2x)
 
     /** An erased value or an inline method.
      */
     def isEffectivelyErased(implicit ctx: Context): Boolean =
-      is(Erased) || isInlineMethod
+      is(Erased) || isInlineMethod && !isInlineRetained
 
     /** ()T and => T types should be treated as equivalent for this symbol.
      *  Note: For the moment, we treat Scala-2 compiled symbols as loose matching,

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -774,7 +774,7 @@ class TreeUnpickler(reader: TastyReader,
       def readRhs(implicit ctx: Context): LazyTree =
         if (nothingButMods(end))
           EmptyTree
-        else if (sym.isInlineMethod)
+        else if sym.isInlineMethod && !sym.is(Deferred) then
           // The body of an inline method is stored in an annotation, so no need to unpickle it again
           new Trees.Lazy[Tree] {
             def complete(implicit ctx: Context) = typer.Inliner.bodyToInline(sym)

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -1699,7 +1699,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   }
   def Symbol_annots(self: Symbol)(using ctx: Context): List[Term] =
     self.annotations.flatMap {
-      case _: core.Annotations.LazyBodyAnnotation => Nil
+      case _: core.Annotations.BodyAnnotation => Nil
       case annot => annot.tree :: Nil
     }
 

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

@@ -12,17 +12,19 @@ import core.Types._
 import core.Names._
 import core.StdNames._
 import core.NameOps._
-import core.NameKinds.AdaptedClosureName
+import core.NameKinds.{AdaptedClosureName, BodyRetainerName}
 import core.Decorators._
 import core.Constants._
 import core.Definitions._
+import core.Annotations.BodyAnnotation
 import typer.{NoChecking, LiftErased}
 import typer.Inliner
 import typer.ProtoTypes._
 import core.TypeErasure._
 import core.Decorators._
 import dotty.tools.dotc.ast.{tpd, untpd}
 import ast.Trees._
+import ast.TreeTypeMap
 import dotty.tools.dotc.core.{Constants, Flags}
 import ValueClasses._
 import TypeUtils._
@@ -78,17 +80,32 @@ class Erasure extends Phase with DenotTransformer {
         val oldInfo = ref.info
         val newInfo = transformInfo(oldSymbol, oldInfo)
         val oldFlags = ref.flags
-        val newFlags =
+        var newFlags =
           if (oldSymbol.is(Flags.TermParam) && isCompacted(oldSymbol.owner)) oldFlags &~ Flags.Param
           else oldFlags &~ Flags.HasDefaultParamsFlags // HasDefaultParamsFlags needs to be dropped because overriding might become overloading
-
+        val oldAnnotations = ref.annotations
+        var newAnnotations = oldAnnotations
+        if oldSymbol.isInlineMethod && oldSymbol.isInlineRetained then
+          newFlags = newFlags &~ Flags.Inline
+          newAnnotations = newAnnotations.filterConserve(!_.isInstanceOf[BodyAnnotation])
         // TODO: define derivedSymDenotation?
-        if ((oldSymbol eq newSymbol) && (oldOwner eq newOwner) && (oldName eq newName) && (oldInfo eq newInfo) && (oldFlags == newFlags))
+        if (oldSymbol eq newSymbol)
+            && (oldOwner eq newOwner)
+            && (oldName eq newName)
+            && (oldInfo eq newInfo)
+            && (oldFlags == newFlags)
+            && (oldAnnotations eq newAnnotations)
+        then
           ref
-        else {
+        else
           assert(!ref.is(Flags.PackageClass), s"trans $ref @ ${ctx.phase} oldOwner = $oldOwner, newOwner = $newOwner, oldInfo = $oldInfo, newInfo = $newInfo ${oldOwner eq newOwner} ${oldInfo eq newInfo}")
-          ref.copySymDenotation(symbol = newSymbol, owner = newOwner, name = newName, initFlags = newFlags, info = newInfo)
-        }
+          ref.copySymDenotation(
+            symbol = newSymbol,
+            owner = newOwner,
+            name = newName,
+            initFlags = newFlags,
+            info = newInfo,
+            annotations = newAnnotations)
       }
     case ref: JointRefDenotation =>
       new UniqueRefDenotation(
@@ -813,7 +830,8 @@ object Erasure {
      *  parameter of type `[]Object`.
      */
     override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context): Tree =
-      if (sym.isEffectivelyErased) erasedDef(sym)
+      if sym.isEffectivelyErased || sym.name.is(BodyRetainerName) then
+        erasedDef(sym)
       else
         val restpe = if sym.isConstructor then defn.UnitType else sym.info.resultType
         var vparams = outerParamDefs(sym)
@@ -874,6 +892,35 @@ object Erasure {
             outerParamDefs(constr)
       else Nil
 
+    private def addRetainedInlineBodies(stats: List[untpd.Tree])(using ctx: Context): List[untpd.Tree] =
+      lazy val retainerDef: Map[Symbol, DefDef] = stats.collect {
+        case stat: DefDef if stat.symbol.name.is(BodyRetainerName) =>
+          val retainer = stat.symbol
+          val origName = retainer.name.asTermName.exclude(BodyRetainerName)
+          val inlineMeth = ctx.atPhase(ctx.typerPhase) {
+            retainer.owner.info.decl(origName)
+              .matchingDenotation(retainer.owner.thisType, stat.symbol.info)
+              .symbol
+          }
+          (inlineMeth, stat)
+      }.toMap
+      stats.mapConserve {
+        case stat: DefDef if stat.symbol.isInlineMethod && stat.symbol.isInlineRetained =>
+          val rdef = retainerDef(stat.symbol)
+          def allParams(ddef: DefDef) =
+            (ddef.tparams ::: ddef.vparamss.flatten).map(_.symbol)
+          val fromParams = allParams(rdef)
+          val toParams = allParams(stat)
+          assert(fromParams.hasSameLengthAs(toParams))
+          val mapBody = TreeTypeMap(
+            oldOwners = rdef.symbol :: Nil,
+            newOwners = stat.symbol :: Nil,
+            substFrom = fromParams,
+            substTo   = toParams)
+          cpy.DefDef(stat)(rhs = mapBody.transform(rdef.rhs))
+        case stat => stat
+      }
+
     override def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context): Tree = {
       val xxl = defn.isXXLFunctionClass(tree.typeOpt.typeSymbol)
       var implClosure = super.typedClosure(tree, pt).asInstanceOf[Closure]
@@ -888,9 +935,10 @@ object Erasure {
       typed(tree.arg, pt)
 
     override def typedStats(stats: List[untpd.Tree], exprOwner: Symbol)(implicit ctx: Context): (List[Tree], Context) = {
+      val stats0 = addRetainedInlineBodies(stats)(using preErasureCtx)
       val stats1 =
-        if (takesBridges(ctx.owner)) new Bridges(ctx.owner.asClass, erasurePhase).add(stats)
-        else stats
+        if (takesBridges(ctx.owner)) new Bridges(ctx.owner.asClass, erasurePhase).add(stats0)
+        else stats0
       val (stats2, finalCtx) = super.typedStats(stats1, exprOwner)
       (stats2.filter(!_.isEmpty), finalCtx)
     }

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

@@ -80,7 +80,8 @@ class TreeChecker extends Phase with SymTransformer {
     val badDeferredAndPrivate =
       sym.is(Method) && sym.is(Deferred) && sym.is(Private)
       && !sym.hasAnnotation(defn.NativeAnnot)
-      && !sym.is(Erased)
+      && !sym.isEffectivelyErased
+
     assert(!badDeferredAndPrivate, i"$sym is both Deferred and Private")
 
     checkCompanion(symd)

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

@@ -472,7 +472,6 @@ object Checking {
         fail(OnlyClassesCanHaveDeclaredButUndefinedMembers(sym))
       checkWithDeferred(Private)
       checkWithDeferred(Final)
-      checkWithDeferred(Inline)
     }
     if (sym.isValueClass && sym.is(Trait) && !sym.isRefinementClass)
       fail(CannotExtendAnyVal(sym))

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

@@ -15,7 +15,7 @@ import StdNames._
 import transform.SymUtils._
 import Contexts.Context
 import Names.{Name, TermName}
-import NameKinds.{InlineAccessorName, InlineBinderName, InlineScrutineeName}
+import NameKinds.{InlineAccessorName, InlineBinderName, InlineScrutineeName, BodyRetainerName}
 import ProtoTypes.selectionProto
 import SymDenotations.SymDenotation
 import Inferencing.isFullyDefined
@@ -124,6 +124,38 @@ object Inliner {
       )
   }
 
+  /** For a retained inline method add a RetainedBody annotaton that
+   *  records the tree for which code will be generated at runtime. This is
+   *  the inline expansion of a call to the method itself with its
+   *  parameters as arguments. Given an inline method
+   *
+   *    inline def f[Ts](xs: Us) = body
+   *
+   *  This sets up the call
+   *
+   *    f[Ts'](xs')
+   *
+   *  where the 'ed parameters are copies of the original ones. The call is
+   *  then inline processed in a context which has a clone f' of f as owner.
+   *  The cloning of owner and parameters is necessary since otherwise the
+   *  inliner gets confused in various ways. The inlined body is then
+   *  transformed back by replacing cloned versions of parameters with original
+   *  and replacing the cloned owner f' with f.
+   */
+  def bodyRetainer(mdef: DefDef)(using ctx: Context): DefDef =
+    val meth = mdef.symbol.asTerm
+
+    val retainer = meth.copy(
+      name = BodyRetainerName(meth.name),
+      flags = meth.flags &~ (Inline | Override) | Private,
+      coord = mdef.rhs.span.startPos).asTerm
+    polyDefDef(retainer, targs => prefss =>
+      inlineCall(
+        ref(meth).appliedToTypes(targs).appliedToArgss(prefss)
+          .withSpan(mdef.rhs.span.startPos))(
+        using ctx.withOwner(retainer)))
+    .reporting(i"retainer for $meth: $result", inlining)
+
   /** Replace `Inlined` node by a block that contains its bindings and expansion */
   def dropInlined(inlined: Inlined)(implicit ctx: Context): Tree =
     if (enclosingInlineds.nonEmpty) inlined // Remove in the outer most inlined call

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

@@ -128,7 +128,7 @@ class ReTyper extends Typer with ReChecking {
         throw ex
     }
 
-  override def inlineExpansion(mdef: DefDef)(implicit ctx: Context): Tree = mdef
+  override def inlineExpansion(mdef: DefDef)(implicit ctx: Context): List[Tree] = mdef :: Nil
 
   override def inferView(from: Tree, to: Type)(implicit ctx: Context): Implicits.SearchResult =
     Implicits.NoMatchingImplicitsFailure

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

@@ -157,8 +157,7 @@ object RefChecks {
    *    1.8.3  M is of type ()S, O is of type []T and S <: T, or
    *    1.9.1  If M is erased, O is erased. If O is erased, M is erased or inline.
    *    1.9.2  If M or O are extension methods, they must both be extension methods.
-   *    1.10   If M is an inline or Scala-2 macro method, O cannot be deferred unless
-   *           there's also a concrete method that M overrides.
+   *    1.10   If O is inline, M must be inline
    *    1.11.  If O is a Scala-2 macro, M must be a Scala-2 macro.
    *  2. Check that only abstract classes have deferred members
    *  3. Check that concrete classes do not have deferred definitions
@@ -398,9 +397,8 @@ object RefChecks {
         overrideError("is an extension method, cannot override a normal method")
       else if (other.isAllOf(ExtensionMethod) && !member.isAllOf(ExtensionMethod)) // (1.9.2)
         overrideError("is a normal method, cannot override an extension method")
-      else if ((member.isInlineMethod || member.isScala2Macro) && other.is(Deferred) &&
-                 member.extendedOverriddenSymbols.forall(_.is(Deferred))) // (1.10)
-        overrideError("is an inline method, must override at least one concrete method")
+      else if other.isInlineMethod && !member.isInlineMethod then // (1.10)
+        overrideError("is not inline, cannot override an inline method")
       else if (other.isScala2Macro && !member.isScala2Macro) // (1.11)
         overrideError("cannot be used here - only Scala-2 macros can override Scala-2 macros")
       else if (!compatibleTypes(memberTp(self), otherTp(self)) &&

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

@@ -2336,8 +2336,9 @@ class Typer extends Namer
             val newCtx = if (ctx.owner.isTerm && adaptCreationContext(mdef)) ctx
               else ctx.withNotNullInfos(initialNotNullInfos)
             typed(mdef)(using newCtx) match {
-              case mdef1: DefDef if !Inliner.bodyToInline(mdef1.symbol).isEmpty =>
-                buf += inlineExpansion(mdef1)
+              case mdef1: DefDef
+              if mdef1.symbol.is(Inline, butNot = Deferred) && !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.
               case mdef1: TypeDef if mdef1.symbol.is(Enum, butNot = Case) =>
@@ -2414,11 +2415,13 @@ class Typer extends Namer
     }
 
   /** Given an inline method `mdef`, the method rewritten so that its body
-   *  uses accessors to access non-public members.
+   *  uses accessors to access non-public members. Also, if the inline method
+   *  is retained, add a method to record the retained version of the body.
    *  Overwritten in Retyper to return `mdef` unchanged.
    */
-  protected def inlineExpansion(mdef: DefDef)(implicit ctx: Context): Tree =
+  protected def inlineExpansion(mdef: DefDef)(implicit ctx: Context): List[Tree] =
     tpd.cpy.DefDef(mdef)(rhs = Inliner.bodyToInline(mdef.symbol))
+    :: (if mdef.symbol.isInlineRetained then Inliner.bodyRetainer(mdef) :: Nil else Nil)
 
   def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, pt)(ctx retractMode Mode.PatternOrTypeBits)
@@ -2936,9 +2939,13 @@ class Typer extends Namer
                !suppressInline) {
         tree.tpe <:< wildApprox(pt)
         val errorCount = ctx.reporter.errorCount
-        val inlined = Inliner.inlineCall(tree)
-        if ((inlined ne tree) && errorCount == ctx.reporter.errorCount) readaptSimplified(inlined)
-        else inlined
+        val meth = methPart(tree).symbol
+        if meth.is(Deferred) then
+          errorTree(tree, i"Deferred inline ${meth.showLocated} cannot be invoked")
+        else
+          val inlined = Inliner.inlineCall(tree)
+          if ((inlined ne tree) && errorCount == ctx.reporter.errorCount) readaptSimplified(inlined)
+          else inlined
       }
       else if (tree.symbol.isScala2Macro &&
                // raw and s are eliminated by the StringInterpolatorOpt phase

docs/docs/reference/metaprogramming/inline.md

@@ -142,6 +142,44 @@ funkyAssertEquals(computeActual(), computeExpected(), computeDelta())
 //    if (actual - expected).abs > computeDelta() then
 //      throw new AssertionError(s"difference between ${expected} and ${actual} was larger than ${computeDelta()}")
 ```
+### Rules for Overriding
+
+Inline methods can override other methods and can themselves be overridden by other inline methods. The rules are as follows:
+
+1. If an inline method `f` implements or overrides another, non-inline method, the inline method can also be invoked at runtime. For instance, consider the scenario:
+```scala
+abstract class A {
+  def f(): Int
+  def g(): Int = f()
+}
+class B extends A {
+  inline def f() = 22
+  override inline def g() = f() + 11
+}
+val b = B()
+val a: A = b
+// inlined invocatons
+assert(b.f() == 22)
+assert(b.g() == 33)
+// dynamic invocations
+assert(a.f() == 22)
+assert(a.g() == 33)
+```
+The inlined invocations and the dynamically dispatched invocations give the same results.
+
+2. Inline methods can override or implement normal methods, as the previous example shows. Inline methods can be overridden only by other inline methods.
+
+3. Inline methods can also be abstract. An abstract inline method can be implemented only by other inline methods. It cannot be invoked directly:
+```scala
+abstract class A {
+  inline def f(): Int
+}
+object B extends A {
+  inline def f(): Int = 22
+}
+B.f()  // OK
+val a: A = B; a.f() // error: cannot inline f() in A.
+```
 
 ### Relationship to @inline
 

tasty/src/dotty/tools/tasty/TastyFormat.scala

@@ -59,8 +59,8 @@ Standard-Section: "ASTs" TopLevelStat*
                   TYPEDEF        Length NameRef (type_Term | Template) Modifier*   -- modifiers type name (= type | bounds)  |  moifiers class name template
                   IMPORT         Length qual_Term Selector*                        -- import qual selectors
   ValOrDefDef   = VALDEF         Length NameRef type_Term rhs_Term? Modifier*      -- modifiers val name : type (= rhs)?
-                  DEFDEF         Length NameRef TypeParam* Params* returnType_Term rhs_Term?
-                                        Modifier*                                  -- modifiers def name [typeparams] paramss : returnType (= rhs)?
+                  DEFDEF         Length NameRef TypeParam* Params* returnType_Term
+                                        rhs_Term? Modifier*                        -- modifiers def name [typeparams] paramss : returnType (= rhs)?
   Selector      = IMPORTED              name_NameRef                               -- name, "_" for normal wildcards, "" for given wildcards
                   RENAMED               to_NameRef                                 -- => name
                   BOUNDED               type_Term                                  -- type bound
@@ -279,6 +279,9 @@ object TastyFormat {
 
     final val INLINEACCESSOR = 21    // The name of an inline accessor `inline$name`
 
+    final val BODYRETAINER = 22      // The name of a synthetic method that retains the runtime
+                                     // body of an inline method
+
     final val OBJECTCLASS = 23       // The name of an object class (or: module class) `<name>$`.
 
     final val SIGNED = 63            // A pair of a name and a signature, used to identify

tests/neg-macros/BigFloat/BigFloatFromDigitsImpl_1.scala

@@ -0,0 +1,16 @@
+package test
+import scala.util.FromDigits
+import scala.quoted._
+
+object BigFloatFromDigitsImpl:
+  def apply(digits: Expr[String])(using ctx: QuoteContext): Expr[BigFloat] =
+    digits match
+      case Const(ds) =>
+        try
+          val BigFloat(m, e) = BigFloat(ds)
+          '{BigFloat(${Expr(m)}, ${Expr(e)})}
+        catch case ex: FromDigits.FromDigitsException =>
+          ctx.error(ex.getMessage)
+          '{BigFloat(0, 0)}
+      case digits =>
+        '{BigFloat($digits)}