Make inline override methods available at runtime

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)
+
     /** 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", 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/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)

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

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)}

tests/neg/BigFloat/BigFloat_1.scala renamed to tests/neg-macros/BigFloat/BigFloat_1.scala

@@ -30,29 +30,13 @@ object BigFloat extends App {
     BigFloat(BigInt(intPart), exponent)
   }
 
-  private def fromDigitsImpl(digits: Expr[String])(using ctx: QuoteContext): Expr[BigFloat] =
-    digits match {
-      case Const(ds) =>
-        try {
-          val BigFloat(m, e) = apply(ds)
-          '{BigFloat(${Expr(m)}, ${Expr(e)})}
-        }
-        catch {
-          case ex: FromDigits.FromDigitsException =>
-            ctx.error(ex.getMessage)
-            '{BigFloat(0, 0)}
-        }
-      case digits =>
-        '{apply($digits)}
-    }
-
   class BigFloatFromDigits extends FromDigits.Floating[BigFloat] {
     def fromDigits(digits: String) = apply(digits)
   }
 
   given BigFloatFromDigits {
     override inline def fromDigits(digits: String) = ${
-      fromDigitsImpl('digits)
+      BigFloatFromDigitsImpl('digits)
     }
   }
 

tests/neg/BigFloat/Test_2.scala renamed to tests/neg-macros/BigFloat/Test_2.scala

@@ -0,0 +1,18 @@
+import scala.util.FromDigits
+import scala.quoted._
+import Even._
+
+object EvenFromDigitsImpl:
+  def apply(digits: Expr[String])(using ctx: QuoteContext): Expr[Even] = digits match {
+    case Const(ds) =>
+      val ev =
+        try evenFromDigits(ds)
+        catch {
+          case ex: FromDigits.FromDigitsException =>
+            ctx.error(ex.getMessage)
+            Even(0)
+        }
+      '{Even(${Expr(ev.n)})}
+    case _ =>
+      '{evenFromDigits($digits)}
+  }

tests/neg-macros/GenericNumLits/EvenFromDigitsImpl_1.scala

@@ -5,33 +5,19 @@ import scala.quoted._
 case class Even(n: Int)
 object Even {
 
-  private def evenFromDigits(digits: String): Even = {
+  def evenFromDigits(digits: String): Even = {
     val intValue = FromDigits.intFromDigits(digits)
     if (intValue % 2 == 0) Even(intValue)
     else throw FromDigits.MalformedNumber(s"$digits is odd")
   }
 
-  private def evenFromDigitsImpl(digits: Expr[String])(using ctx: QuoteContext): Expr[Even] = digits match {
-    case Const(ds) =>
-      val ev =
-        try evenFromDigits(ds)
-        catch {
-          case ex: FromDigits.FromDigitsException =>
-            ctx.error(ex.getMessage)
-            Even(0)
-        }
-      '{Even(${Expr(ev.n)})}
-    case _ =>
-      '{evenFromDigits($digits)}
-  }
-
   class EvenFromDigits extends FromDigits[Even] {
     def fromDigits(digits: String) = evenFromDigits(digits)
   }
 
   given EvenFromDigits {
     override inline def fromDigits(digits: String) = ${
-      evenFromDigitsImpl('digits)
+      EvenFromDigitsImpl('digits)
     }
   }
 }

tests/neg-macros/GenericNumLits/Even_1.scala

@@ -0,0 +1,18 @@
+import scala.util.FromDigits
+import scala.quoted._
+import Even._
+
+object EvenFromDigitsImpl:
+  def apply(digits: Expr[String])(using ctx: QuoteContext): Expr[Even] = digits match {
+    case Const(ds) =>
+      val ev =
+        try evenFromDigits(ds)
+        catch {
+          case ex: FromDigits.FromDigitsException =>
+            ctx.error(ex.getMessage)
+            Even(0)
+        }
+      '{Even(${Expr(ev.n)})}
+    case _ =>
+      '{evenFromDigits($digits)}
+  }

tests/neg-with-compiler/GenericNumLits/EvenFromDigitsImpl_1.scala

@@ -5,33 +5,19 @@ import scala.quoted._
 case class Even(n: Int)
 object Even {
 
-  private def evenFromDigits(digits: String): Even = {
+  def evenFromDigits(digits: String): Even = {
     val intValue = FromDigits.intFromDigits(digits)
     if (intValue % 2 == 0) Even(intValue)
     else throw FromDigits.MalformedNumber(s"$digits is odd")
   }
 
-  private def evenFromDigitsImpl(digits: Expr[String])(using ctx: QuoteContext): Expr[Even] = digits match {
-    case Const(ds) =>
-      val ev =
-        try evenFromDigits(ds)
-        catch {
-          case ex: FromDigits.FromDigitsException =>
-            ctx.error(ex.getMessage)
-            Even(0)
-        }
-      '{Even(${Expr(ev.n)})}
-    case _ =>
-      '{evenFromDigits($digits)}
-  }
-
   class EvenFromDigits extends FromDigits[Even] {
     def fromDigits(digits: String) = evenFromDigits(digits)
   }
 
   given EvenFromDigits {
     override inline def fromDigits(digits: String) = ${
-      evenFromDigitsImpl('digits)
+      EvenFromDigitsImpl('digits)
     }
   }
 }