Track inline proxies

Track proxies of inline arguments with a flag.

Note: Some of the optimizations of the inliner don't update the
defTree of the argument symbol even if they change the definition.
But most of these optimizations will go away anyway. We should
review once the inliner stabilizes.

Author: odersky

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

@@ -351,6 +351,9 @@ object Flags {
   /** A bridge method. Set by Erasure */
   final val Bridge = termFlag(34, "<bridge>")
 
+  /** A proxy for an argument to an inline method */
+  final val InlineProxy = termFlag(35, "<inline proxy>")
+
   /** Symbol is a method which should be marked ACC_SYNCHRONIZED */
   final val Synchronized = termFlag(36, "<synchronized>")
 
@@ -545,6 +548,9 @@ object Flags {
   /** Either method or lazy or deferred */
   final val MethodOrLazyOrDeferred = Method | Lazy | Deferred
 
+  /** An inline method or inline argument proxy */
+  final val InlineOrProxy = Inline | InlineProxy
+
   /** Assumed to be pure */
   final val StableOrErased = Stable | Erased
 

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

@@ -447,8 +447,8 @@ object Symbols {
      */
     def retainsDefTree(implicit ctx: Context): Boolean =
       ctx.settings.YretainTrees.value ||
-      denot.owner.isTerm || // no risk of leaking memory after a run for these
-      denot.is(Inline)      // need to keep inline info
+      denot.owner.isTerm ||        // no risk of leaking memory after a run for these
+      denot.is(InlineOrProxy)      // need to keep inline info
 
     /** The last denotation of this symbol */
     private[this] var lastDenot: SymDenotation = _

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

@@ -186,6 +186,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   OVERRIDE
                   INLINE
                   MACRO                               // inline method containing toplevel splices
+                  INLINEPROXY                         // symbol of binding representing an inline parameter
                   STATIC                              // mapped to static Java member
                   OBJECT                              // an object or its class
                   TRAIT                               // a trait
@@ -299,7 +300,7 @@ object TastyFormat {
   final val IMPLICIT = 13
   final val LAZY = 14
   final val OVERRIDE = 15
-
+  final val INLINEPROXY = 16
   final val INLINE = 17
   final val STATIC = 18
   final val OBJECT = 19
@@ -483,6 +484,7 @@ object TastyFormat {
        | LAZY
        | OVERRIDE
        | INLINE
+       | INLINEPROXY
        | MACRO
        | STATIC
        | OBJECT
@@ -540,6 +542,7 @@ object TastyFormat {
     case LAZY => "LAZY"
     case OVERRIDE => "OVERRIDE"
     case INLINE => "INLINE"
+    case INLINEPROXY => "INLINEPROXY"
     case MACRO => "MACRO"
     case STATIC => "STATIC"
     case OBJECT => "OBJECT"

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

@@ -620,6 +620,7 @@ class TreePickler(pickler: TastyPickler) {
     if (flags is Case) writeByte(CASE)
     if (flags is Override) writeByte(OVERRIDE)
     if (flags is Inline) writeByte(INLINE)
+    if (flags is InlineProxy) writeByte(INLINEPROXY)
     if (flags is Macro) writeByte(MACRO)
     if (flags is JavaStatic) writeByte(STATIC)
     if (flags is Module) writeByte(OBJECT)

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

@@ -599,6 +599,7 @@ class TreeUnpickler(reader: TastyReader,
           case LAZY => addFlag(Lazy)
           case OVERRIDE => addFlag(Override)
           case INLINE => addFlag(Inline)
+          case INLINEPROXY => addFlag(InlineProxy)
           case MACRO => addFlag(Macro)
           case STATIC => addFlag(JavaStatic)
           case OBJECT => addFlag(Module)

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

@@ -236,14 +236,16 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
                               bindingsBuf: mutable.ListBuffer[MemberDef]): MemberDef = {
     val argtpe = arg.tpe.dealiasKeepAnnots
     val isByName = paramtp.dealias.isInstanceOf[ExprType]
-    val inlineFlag = if (paramtp.hasAnnotation(defn.InlineParamAnnot)) Inline else EmptyFlags
+    var inlineFlag = InlineProxy
+    if (paramtp.hasAnnotation(defn.InlineParamAnnot)) inlineFlag |= Inline
     val (bindingFlags, bindingType) =
-      if (isByName) (Method, ExprType(argtpe.widen))
+      if (isByName) (Method | InlineProxy, ExprType(argtpe.widen))
       else (inlineFlag, argtpe.widen)
     val boundSym = newSym(name, bindingFlags, bindingType).asTerm
     val binding =
       if (isByName) DefDef(boundSym, arg.changeOwner(ctx.owner, boundSym))
       else ValDef(boundSym, arg)
+    boundSym.defTree = binding
     bindingsBuf += binding
     binding
   }
@@ -295,7 +297,9 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           ref(rhsClsSym.sourceModule)
         else
           inlineCallPrefix
-      bindingsBuf += ValDef(selfSym.asTerm, rhs)
+      val binding = ValDef(selfSym.asTerm, rhs)
+      bindingsBuf += binding
+      selfSym.defTree = binding
       inlining.println(i"proxy at $level: $selfSym = ${bindingsBuf.last}")
       lastSelf = selfSym
       lastLevel = level
@@ -323,7 +327,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     case tpe: ThisType if !canElideThis(tpe) && !thisProxy.contains(tpe.cls) =>
       val proxyName = s"${tpe.cls.name}_this".toTermName
       val proxyType = tpe.asSeenFrom(inlineCallPrefix.tpe, inlinedMethod.owner)
-      thisProxy(tpe.cls) = newSym(proxyName, Synthetic, proxyType).termRef
+      thisProxy(tpe.cls) = newSym(proxyName, InlineProxy, proxyType).termRef
       if (!tpe.cls.isStaticOwner)
         registerType(inlinedMethod.owner.thisType) // make sure we have a base from which to outer-select
     case tpe: NamedType