Make inline override methods available at runtime

... unless they are declated erased.

Author: odersky

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

@@ -53,6 +53,8 @@ object Contexts {
   /** The current context */
   def curCtx(using ctx: Context): Context = ctx
 
+  type Ctx[+T] = Context ?=> T
+
   /** A context is passed basically everywhere in dotc.
    *  This is convenient but carries the risk of captured contexts in
    *  objects that turn into space leaks. To combat this risk, here are some

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

@@ -368,7 +368,7 @@ object SymDenotations {
       annots.iterator.foreach(addAnnotation)
 
     @tailrec
-    private def dropOtherAnnotations(anns: List[Annotation], cls: Symbol)(implicit ctx: Context): List[Annotation] = anns match {
+    final def dropOtherAnnotations(anns: List[Annotation], cls: Symbol)(implicit ctx: Context): List[Annotation] = anns match {
       case ann :: rest => if (ann matches cls) anns else dropOtherAnnotations(rest, cls)
       case Nil => Nil
     }
@@ -938,13 +938,15 @@ object SymDenotations {
     def isInlineMethod(implicit ctx: Context): Boolean =
       isAllOf(InlineMethod, butNot = Accessor)
 
+    def isInlineRetained: Ctx[Boolean] = is(Override, butNot = Erased)
+
     /** 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/TreePickler.scala

@@ -517,7 +517,12 @@ class TreePickler(pickler: TastyPickler) {
           def pickleAllParams =
             pickleParams(tree.tparams)
             pickleParamss(tree.vparamss)
-          pickleDef(DEFDEF, tree.symbol, tree.tpt, tree.rhs, pickleAllParams)
+          val meth = tree.symbol
+          val rhs =
+            if meth.isInlineMethod && meth.isInlineRetained
+            then Alternative(List(Inliner.bodyToInline(meth), tree.rhs))
+            else tree.rhs
+          pickleDef(DEFDEF, meth, tree.tpt, rhs, pickleAllParams)
         case tree: TypeDef =>
           pickleDef(TYPEDEF, tree.symbol, tree.rhs)
         case tree: Template =>

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

@@ -583,9 +583,9 @@ class TreeUnpickler(reader: TastyReader,
       else if (sym.isInlineMethod)
         sym.addAnnotation(LazyBodyAnnotation { ctx0 =>
           val ctx1 = localContext(sym)(ctx0).addMode(Mode.ReadPositions)
-          implicit val ctx: Context = sourceChangeContext(Addr(0))(ctx1)
+          given Context = sourceChangeContext(Addr(0))(ctx1)
             // avoids space leaks by not capturing the current context
-          forkAt(rhsStart).readTerm()
+          forkAt(rhsStart).readInlineBodyPart(compileTime = true)
         })
       goto(start)
       sym
@@ -775,10 +775,13 @@ class TreeUnpickler(reader: TastyReader,
         if (nothingButMods(end))
           EmptyTree
         else if (sym.isInlineMethod)
-          // 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)
-          }
+          if sym.isInlineRetained then
+            readLater(end, rdr => ctx =>
+              rdr.readInlineBodyPart(compileTime = false)(using ctx.retractMode(Mode.InSuperCall)))
+          else // 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)
+            }
         else
           readLater(end, rdr => ctx => rdr.readTerm()(ctx.retractMode(Mode.InSuperCall)))
 
@@ -1281,6 +1284,14 @@ class TreeUnpickler(reader: TastyReader,
       setSpan(start, CaseDef(pat, guard, rhs))
     }
 
+    def readInlineBodyPart(compileTime: Boolean): Ctx[Tree] =
+      if nextByte == ALTERNATIVE then
+        readByte()
+        readEnd()
+        if !compileTime then readTerm()
+      else assert(compileTime)
+      readTerm()
+
     def readLater[T <: AnyRef](end: Addr, op: TreeReader => Context => T)(implicit ctx: Context): Trees.Lazy[T] =
       readLaterWithOwner(end, op)(ctx)(ctx.owner)
 

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

@@ -15,7 +15,7 @@ import Denotations._
 import SymDenotations._
 import StdNames.{nme, tpnme}
 import ast.{Trees, untpd}
-import typer.{Implicits, Namer, Applications}
+import typer.{Implicits, Namer, Applications, Inliner}
 import typer.ProtoTypes._
 import Trees._
 import TypeApplications._
@@ -726,7 +726,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
     sym.annotations.filterNot(ann => dropAnnotForModText(ann.symbol)).map(_.tree))
 
-  protected def dropAnnotForModText(sym: Symbol): Boolean = sym == defn.BodyAnnot
+  protected def dropAnnotForModText(sym: Symbol): Boolean =
+    sym == defn.BodyAnnot && !printDebug
 
   protected def optAscription[T >: Untyped](tpt: Tree[T]): Text = optText(tpt)(": " ~ _)
 
@@ -779,16 +780,20 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
     import untpd.{modsDeco => _}
     dclTextOr(tree) {
-      val defKeyword = modText(tree.mods, tree.symbol, keywordStr("def"), isType = false)
-      val isExtension = tree.hasType && tree.symbol.is(Extension)
+      val meth = tree.symbol
+      val defKeyword = modText(tree.mods, meth, keywordStr("def"), isType = false)
+      val isExtension = tree.hasType && meth.is(Extension)
       withEnclosingDef(tree) {
         val (prefix, vparamss) =
           if (isExtension) (defKeyword ~~ paramsText(tree.vparamss.head) ~~ valDefText(nameIdText(tree)), tree.vparamss.tail)
           else (defKeyword ~~ valDefText(nameIdText(tree)), tree.vparamss)
-
+        val rhs =
+          if meth.isInlineMethod && meth.isInlineRetained && !printDebug
+          then Inliner.bodyToInline(meth)
+          else tree.rhs
         addVparamssText(prefix ~ tparamsText(tree.tparams), vparamss) ~
           optAscription(tree.tpt) ~
-          optText(tree.rhs)(" = " ~ _)
+          optText(rhs)(" = " ~ _)
       }
     }
   }

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

@@ -78,17 +78,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(_.symbol != defn.BodyAnnot)
         // 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(

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

@@ -124,6 +124,26 @@ object Inliner {
       )
   }
 
+  /** For a retained inline method: The inline expansion of the call to itself with its
+   *  parameters as arguments.
+   */
+  def inlineSelfCall(mdef: DefDef)(using ctx: Context): Tree =
+    val meth = mdef.symbol
+    val origParams: List[Symbol] = mdef.tparams.map(_.symbol) ::: mdef.vparamss.flatten.map(_.symbol)
+    val callParams: List[Symbol] = origParams.map(_.copy())
+    val callOwner = meth.copy(flags = meth.flags &~ Inline)
+    assert(ctx.owner != meth)
+    inlineCall(
+      ref(meth)
+        .appliedToTypes(mdef.tparams.tpes)
+        .appliedToArgss(mdef.vparamss.map(_.map(param => ref(param.symbol))))
+        .withSpan(mdef.rhs.span)
+        .subst(origParams, callParams)
+      )(using ctx.withOwner(callOwner))
+      .subst(callParams, origParams)
+      .changeOwner(callOwner, meth)
+      .reporting(i"icall for $meth: $result")
+
   /** 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/RefChecks.scala

@@ -155,7 +155,7 @@ object RefChecks {
    *    1.8.1  M's type is a subtype of O's type, or
    *    1.8.2  M is of type []S, O is of type ()T and S <: T, or
    *    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.1  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.
@@ -390,8 +390,6 @@ object RefChecks {
         overrideError("may not override a non-lazy value")
       else if (other.is(Lazy) && !other.isRealMethod && !member.is(Lazy))
         overrideError("must be declared lazy to override a lazy value")
-      else if (member.is(Erased) && !other.is(Erased)) // (1.9.1)
-        overrideError("is erased, cannot override non-erased member")
       else if (other.is(Erased) && !member.isOneOf(Erased | Inline)) // (1.9.1)
         overrideError("is not erased, cannot override erased member")
       else if (member.isAllOf(ExtensionMethod) && !other.isAllOf(ExtensionMethod)) // (1.9.2)

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

@@ -2418,7 +2418,10 @@ class Typer extends Namer
    *  Overwritten in Retyper to return `mdef` unchanged.
    */
   protected def inlineExpansion(mdef: DefDef)(implicit ctx: Context): Tree =
-    tpd.cpy.DefDef(mdef)(rhs = Inliner.bodyToInline(mdef.symbol))
+    val meth = mdef.symbol
+    tpd.cpy.DefDef(mdef)(rhs =
+      if meth.isInlineRetained then Inliner.inlineSelfCall(mdef)
+      else Inliner.bodyToInline(meth)) // TODO: make that an empty tree
 
   def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, pt)(ctx retractMode Mode.PatternOrTypeBits)

tests/neg/BigFloat/BigFloat_1.scala

@@ -51,7 +51,7 @@ object BigFloat extends App {
   }
 
   given BigFloatFromDigits {
-    override inline def fromDigits(digits: String) = ${
+    erased override inline def fromDigits(digits: String) = ${
       fromDigitsImpl('digits)
     }
   }

tests/run/inline-override.check

@@ -0,0 +1,2 @@
+inline 22
+inline 22

tests/run/inline-override.scala

@@ -0,0 +1,13 @@
+class A:
+  def f(x: Int) = s"dynamic $x"
+
+class B extends A:
+  inline override def f(x: Int) = g(x)
+  inline def g(x: Int) = s"inline $x"
+
+@main def Test =
+  val b = B()
+  println(b.f(22))
+  val a: A = b
+  println(a.f(22))
+

tests/run/quote-MacroOverride.scala

@@ -16,7 +16,7 @@ object Test {
     val a: A = B
     assert(a.f1() == "A.f1")
     assert(a.f2() == "A.f2")
-    assert(a.f3() == "A.f3")
+    assert(a.f3() == "B.f3")
 
     val b: B.type = B
     assert(b.f1() == "B.f1")

tests/run/typeclass-derivation2b.scala

@@ -49,7 +49,7 @@ object Lst {
       case x: Cons[_] => 0
       case Nil => 1
     }
-    inline override def alternative(inline n: Int) <: GenericProduct[_ <: Lst[T]] =
+    inline erased override def alternative(inline n: Int) <: GenericProduct[_ <: Lst[T]] =
       inline n match {
         case 0 => Cons.GenericCons[T]
         case 1 => Nil.GenericNil

tests/run/typelevel-overrides.scala

@@ -10,20 +10,23 @@ class A extends T {
 class B extends A {
   override inline def f(x: Int) = inline x match {
     case 0 => 0
-    case x => x
+    case x => x + 2
   }
 }
 class C extends A with U {
   override inline def f(x: Int) = inline x match {
     case 0 => 0
-    case x => x
+    case x => x + 2
   }
 }
 object Test extends App {
   val a: A = new B
-  assert(a.f(0) == 0)
+  assert(a.f(0) == 2, a.f(0))
+  assert(a.f(1) == 3)
   val b: B = new B
   assert(b.f(0) == 0)
+  assert(b.f(1) == 3)
   val c: A = new C
-  assert(c.f(0) == 1, c.f(0))
+  assert(c.f(0) == 2, c.f(0))
+  assert(c.f(1) == 3, c.f(1))
 }