Improvements to Inliner

 - Allow to recognize Inlined nodes as closure defs
 - Inline also pure valdefs that are used only once (was restricted to methods only)
 - Beta reduce again after inlining closures that are used only once

Author: odersky

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

@@ -418,6 +418,8 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   def isPureExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= Pure
   def isIdempotentExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= Idempotent
 
+  def isPureBinding(tree: Tree)(implicit ctx: Context) = statPurity(tree) >= Pure
+
   /** The purity level of this reference.
    *  @return
    *    SimplyPure  if reference is (nonlazy and stable) or to a parameterized function
@@ -579,11 +581,15 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   /** An extractor for def of a closure contained the block of the closure. */
   object closureDef {
-    def unapply(tree: Tree): Option[DefDef] = tree match {
-      case Block(Nil, expr) => unapply(expr)
+    def unapply(tree: Tree)(implicit ctx: Context): Option[DefDef] = tree match {
       case Block((meth @ DefDef(nme.ANON_FUN, _, _, _, _)) :: Nil, closure: Closure) =>
         Some(meth)
-      case _ => None
+      case Block(Nil, expr) =>
+        unapply(expr)
+      case Inlined(_, bindings, expr) if bindings.forall(isPureBinding) =>
+        unapply(expr)
+      case _ =>
+        None
     }
   }
 

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

@@ -794,22 +794,24 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     countRefs.traverse(tree)
     for (binding <- bindings) countRefs.traverse(binding)
     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) match {
-                    case binding: ValOrDefDef => integrate(binding.rhs, sym)
-                  }
-                case none => t
+      override def transform(t: Tree)(implicit ctx: Context) = t match {
+        case t: RefTree =>
+          val sym = t.symbol
+          val t1 = refCount.get(sym) match {
+            case Some(1) =>
+              bindingOfSym(sym) match {
+                case binding: ValOrDefDef => integrate(binding.rhs, sym)
               }
-            case _ => t
+            case none => t
           }
-        }
+          super.transform(t1)
+        case t: Apply =>
+          val t1 = super.transform(t)
+          if (t1 `eq` t) t else reducer.betaReduce(t1)
+        case _ =>
+          super.transform(t)
       }
+    }
     def retain(binding: MemberDef) = refCount.get(binding.symbol) match {
       case Some(x) => x > 1 || x == 1 && !binding.symbol.is(Method)
       case none => true

tests/run-with-compiler/i3876-d.check

@@ -1,8 +1,5 @@
 6
 {
   val x$1: scala.Int = 3
-
-  { // inlined
-    x$1.+(x$1)
-  }
+  x$1.+(x$1)
 }

tests/run/transparent-foreach.scala

@@ -0,0 +1,70 @@
+// A demonstrator how `transparent override` can be used to sepcialize inherited methods
+trait Iterable[+A] {
+  def foreach(f: A => Unit): Unit
+}
+// The unconventional definition of `Range` and `UntilRange` is needed so
+// that `UntiRange` is recognized as a Noinits class. Our purity predictor
+// for classes currently bails out for arguments passed to parent classes
+// and for concrete `val`s. That's because the predictor runs on untyped trees
+// so there's no way to predict whether an expression is pure or not.
+// It would be nice if we could improve the predictor to work with typed trees.
+// The tricky bit is doing this without causing cycles. That's the price we
+// pay for making inlining a typelevel computation.
+// One possible way to do it would be to make purity a property that's computed on demand,
+// just like info, but evaluated later. Then we might still cause cycles, but these
+// would be "justified" by inlining attempts. I.e. you could avoid a cycle by
+// inlining less.
+abstract class Range extends Iterable[Int]  {
+  val start: Int
+  val end: Int
+  def step: Int
+  def inclusive: Boolean
+  def foreach(f: Int => Unit): Unit = {
+    var idx = start
+    while (
+      if (step > 0)
+        if (inclusive) idx <= end else idx < end
+      else
+        if (inclusive) idx >= end else idx > end
+    ) {
+      f(idx)
+      idx = idx + step
+    }
+  }
+}
+class UntilRange(val start: Int, val end: Int) extends Range {
+  def step = 1
+  def inclusive = false
+  transparent override def foreach(f: Int => Unit): Unit = {
+    var idx = start
+    while (idx < end) {
+      f(idx)
+      idx += 1
+    }
+  }
+}
+object Test extends App {
+  var x = 0
+  new UntilRange(1, 10).foreach(x += _)
+    // Expands to:
+    //    var idx: Int = 1
+    //    while idx < 10 do
+    //      x = x * idx
+    //      idx = idx + 1
+    //    }
+
+  class IntDeco(val x: Int) extends AnyVal {
+    transparent def until(y: Int) = new UntilRange(x, y)
+  }
+  implicit transparent def intDeco(x: Int): IntDeco = new IntDeco(x)
+    // So far, the decorator has to be an explicit def, since
+    // we can inline only methods defined in source. So an implicit class
+    // will not work. We can make this work by making `Desugar` smarter
+    // and generate a transparent with pre-defined "BodyToInline" annotation.
+    // It's doable, just extra work.
+
+  (1 until 10).foreach(x += _)
+    // expands to same as above
+
+  assert(x == 90)
+}