Drop redundant bindings when inlining

Author: odersky

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

@@ -15,7 +15,7 @@ import StdNames.nme
 import Contexts.Context
 import Names.{Name, TermName, EmptyTermName}
 import NameOps._
-import NameKinds.{ClassifiedNameKind, InlineAccessorName}
+import NameKinds.{ClassifiedNameKind, InlineAccessorName, UniqueName}
 import ProtoTypes.selectionProto
 import SymDenotations.SymDenotation
 import Annotations._
@@ -216,7 +216,8 @@ object Inliner {
       for (iref <- referenced.implicitRefs.toList) yield {
         val localImplicit = iref.symbol.asTerm.copy(
           owner = inlineMethod,
-          flags = Implicit | Method,
+          name = UniqueName.fresh(iref.symbol.name.asTermName),
+          flags = Implicit | Method | Stable,
           info = iref.symbol.info.ensureMethodic,
           coord = inlineMethod.pos).asTerm
         polyDefDef(localImplicit, tps => vrefss =>
@@ -530,10 +531,12 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       /** All bindings in `bindingsBuf` except bindings of inlineable closures */
       val bindings = bindingsBuf.toList.map(_.withPos(call.pos))
 
+      val (finalBindings, finalExpansion) = dropUnusedDefs(bindings, expansion1)
+
       //println(i"bindings buf = ${bindingsBuf.toList}%; %")
       //println(i"bindings = ${bindings.toList}%; %")
 
-      tpd.Inlined(call, bindings, expansion1)
+      tpd.Inlined(call, finalBindings, finalExpansion)
     }
   }
 
@@ -625,4 +628,76 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
 
     override def newLikeThis: Typer = new InlineTyper
   }
+
+  /** Drop any side-effect-free bindings that are unused in expansion or other reachable bindings.
+   *  Inline def bindings that are used only once.
+   */
+  def dropUnusedDefs(bindings: List[ValOrDefDef], tree: Tree)(implicit ctx: Context): (List[ValOrDefDef], Tree) = {
+    val refCount = newMutableSymbolMap[Int]
+    val bindingOfSym = newMutableSymbolMap[ValOrDefDef]
+    def isInlineable(binding: ValOrDefDef) = binding match {
+      case DefDef(_, Nil, Nil, _, _) => true
+      case vdef @ ValDef(_, _, _) => isPureExpr(vdef.rhs)
+      case _ => false
+    }
+    for (binding <- bindings if isInlineable(binding)) {
+      refCount(binding.symbol) = 0
+      bindingOfSym(binding.symbol) = binding
+    }
+    val countRefs = new TreeTraverser {
+      override def traverse(t: Tree)(implicit ctx: Context) = {
+        t match {
+          case t: RefTree =>
+            refCount.get(t.symbol) match {
+              case Some(x) => refCount(t.symbol) = x + 1
+              case none =>
+            }
+          case _: New | _: TypeTree =>
+            //println(i"refcount ${t.tpe}")
+            t.tpe.foreachPart {
+              case ref: TermRef =>
+                refCount.get(ref.symbol) match {
+                  case Some(x) => refCount(ref.symbol) = x + 2
+                  case none =>
+                }
+              case _ =>
+            }
+          case _ =>
+        }
+        traverseChildren(t)
+      }
+    }
+    countRefs.traverse(tree)
+    for (binding <- bindings) countRefs.traverse(binding.rhs)
+    val inlineBindings = new TreeMap {
+      override def transform(t: Tree)(implicit ctx: Context) =
+        super.transform {
+          t match {
+            case t: RefTree =>
+              val sym = t.symbol
+              refCount.get(sym) match {
+                case Some(1) if sym.is(Method) =>
+                  bindingOfSym(sym).rhs.changeOwner(sym, ctx.owner)
+                case none => t
+              }
+            case _ => t
+          }
+        }
+      }
+    def retain(binding: ValOrDefDef) = refCount.get(binding.symbol) match {
+      case Some(x) => x > 1 || x == 1 && !binding.symbol.is(Method)
+      case none => true
+    }
+    val retained = bindings.filterConserve(retain)
+    if (retained `eq` bindings) {
+      //println(i"DONE\n${bindings}%\n% ;;;\n ${tree}")
+      (bindings, tree)
+    }
+    else {
+      val expanded = inlineBindings.transform(tree)
+      //println(i"ref counts: ${refCount.toMap map { case (sym, count) => i"$sym -> $count" }}")
+      //println(i"""MAPPING\n${bindings}%\n% ;;;\n ${tree} \n------->\n${retained}%\n%;;;\n ${expanded} """)
+      dropUnusedDefs(retained, expanded)
+    }
+  }
 }