Merge pull request #8543 from dotty-staging/change-inline-override

Implement inline override

Author: nicolasstucki

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

@@ -191,13 +191,9 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case arg => arg.typeOpt.widen.isRepeatedParam
   }
 
-  /** If this tree has type parameters, those.  Otherwise Nil.
-  def typeParameters(tree: Tree): List[TypeDef] = tree match {
-    case DefDef(_, _, tparams, _, _, _) => tparams
-    case ClassDef(_, _, tparams, _)     => tparams
-    case TypeDef(_, _, tparams, _)      => tparams
-    case _                              => Nil
-  }*/
+  /** All type and value parameter symbols of this DefDef */
+  def allParamSyms(ddef: DefDef)(using Context): List[Symbol] =
+    (ddef.tparams ::: ddef.vparamss.flatten).map(_.symbol)
 
   /** Does this argument list end with an argument of the form <expr> : _* ? */
   def isWildcardStarArgList(trees: List[Tree])(implicit ctx: Context): Boolean =

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

@@ -519,6 +519,7 @@ object Flags {
   val AbstractSealed: FlagSet                = Abstract | Sealed
   val AbstractOrTrait: FlagSet               = Abstract | Trait
   val EffectivelyOpenFlags                   = Abstract | JavaDefined | Open | Scala2x | Trait
+  val AccessorOrDeferred: FlagSet            = Accessor | Deferred
   val PrivateAccessor: FlagSet               = Accessor | Private
   val AccessorOrSynthetic: FlagSet           = Accessor | Synthetic
   val EnumCase: FlagSet                      = Case | Enum

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

@@ -353,7 +353,7 @@ object NameKinds {
   val ProtectedAccessorName: PrefixNameKind = new PrefixNameKind(PROTECTEDACCESSOR, "protected$")
   val InlineAccessorName: PrefixNameKind = new PrefixNameKind(INLINEACCESSOR, "inline$")
 
-  val AvoidClashName: SuffixNameKind = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$")
+  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/NameOps.scala

@@ -128,7 +128,7 @@ object NameOps {
     /** If flags is a ModuleClass but not a Package, add module class suffix */
     def adjustIfModuleClass(flags: FlagSet): N = likeSpacedN {
       if (flags.is(ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
-      else name.toTermName.exclude(AvoidClashName)
+      else name.toTermName
     }
 
     /** The expanded name.

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

@@ -17,13 +17,6 @@ object NameTags extends TastyFormat.NameTags {
 
   final val INITIALIZER = 26    // A mixin initializer method
 
-  final val AVOIDCLASH = 27     // Adds a suffix to avoid a name clash;
-                                // Used in FirstTransform for synthesized companion objects of classes
-                                // if they would clash with another value.
-
-  final val DIRECT = 28         // Used by ShortCutImplicits for the name of methods that
-                                // implement implicit function result types directly.
-
   final val FIELD = 29          // Used by Memoize to tag the name of a class member field.
 
   final val EXTMETH = 30        // Used by ExtensionMethods for the name of an extension method
@@ -51,8 +44,6 @@ object NameTags extends TastyFormat.NameTags {
     case INLINEACCESSOR => "INLINEACCESSOR"
     case PROTECTEDACCESSOR => "PROTECTEDACCESSOR"
     case INITIALIZER => "INITIALIZER"
-    case AVOIDCLASH => "AVOIDCLASH"
-    case DIRECT => "DIRECT"
     case FIELD => "FIELD"
     case EXTMETH => "EXTMETH"
     case IMPLMETH => "IMPLMETH"

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

@@ -282,7 +282,7 @@ object SymDenotations {
      */
     def effectiveName(implicit ctx: Context): Name =
       if (this.is(ModuleClass)) name.stripModuleClassSuffix
-      else name.exclude(AvoidClashName)
+      else name
 
     /** The privateWithin boundary, NoSymbol if no boundary is given.
      */
@@ -940,13 +940,17 @@ object SymDenotations {
     def isInlineMethod(implicit ctx: Context): Boolean =
       isAllOf(InlineMethod, butNot = Accessor)
 
+    def isRetainedInlineMethod(using Context): Boolean =
+      isAllOf(InlineMethod, butNot = AccessorOrDeferred)
+      && 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 && !isRetainedInlineMethod
 
     /** ()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

@@ -1701,7 +1701,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.isRetainedInlineMethod 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,50 @@ object Erasure {
             outerParamDefs(constr)
       else Nil
 
+    /** For all statements in stats: given a retained inline method and
+     *  its retainedBody method such as
+     *
+     *     inline override def f(x: T) = body1
+     *     private def f$retainedBody(x: T) = body2
+     *
+     *  return the runtime version of `f` as
+     *
+     *     override def f(x: T) = body2
+     *
+     *  Here, the owner of body2 is changed to f and all references
+     *  to parameters of f$retainedBody are changed to references of
+     *  corresponding parameters in f.
+     *
+     *  `f$retainedBody` is subseqently mapped to the empty tree in `typedDefDef`
+     *  which is then dropped in `typedStats`.
+     */
+    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.isRetainedInlineMethod =>
+          val rdef = retainerDef(stat.symbol)
+          val fromParams = untpd.allParamSyms(rdef)
+          val toParams = untpd.allParamSyms(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 +950,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/HoistSuperArgs.scala

@@ -69,7 +69,7 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
         if (constr == cls.primaryConstructor)
           cls.info.decls.filter(d => d.is(TypeParam) || d.is(ParamAccessor))
         else
-          (cdef.tparams ::: cdef.vparamss.flatten).map(_.symbol)
+          allParamSyms(cdef)
 
       /** The parameter references defined by the constructor info */
       def allParamRefs(tp: Type): List[ParamRef] = tp match {