Inline by-name parameters directly

Do not bind them to an auxiliary method. This has the advantage that
we pass the actual quoted arguments to a macro implementation instead
of passing proxies.

To avoid code duplication, inline methods using an argument more than once
should create a local auxiliary method instead. This is done in `trace.scala`
and `Stats.scala`.

Author: odersky

compiler/src/dotty/tools/dotc/reporting/trace.scala

@@ -14,14 +14,18 @@ object trace {
     conditionally(ctx.settings.YdebugTrace.value, question, false)(op)
 
   @inline
-  def conditionally[TC](cond: Boolean, question: => String, show: Boolean)(op: => TC)(implicit ctx: Context): TC =
-    if (Config.tracingEnabled && cond) apply[TC](question, Printers.default, show)(op)
-    else op
+  def conditionally[TC](cond: Boolean, question: => String, show: Boolean)(op: => TC)(implicit ctx: Context): TC = {
+    def op1 = op
+    if (Config.tracingEnabled && cond) apply[TC](question, Printers.default, show)(op1)
+    else op1
+  }
 
   @inline
-  def apply[T](question: => String, printer: Printers.Printer, show: Boolean)(op: => T)(implicit ctx: Context): T =
-    if (!Config.tracingEnabled || printer.eq(config.Printers.noPrinter)) op
-    else doTrace[T](question, printer, show)(op)
+  def apply[T](question: => String, printer: Printers.Printer, show: Boolean)(op: => T)(implicit ctx: Context): T = {
+    def op1 = op
+    if (!Config.tracingEnabled || printer.eq(config.Printers.noPrinter)) op1
+    else doTrace[T](question, printer, show)(op1)
+  }
 
   @inline
   def apply[T](question: => String, printer: Printers.Printer)(op: => T)(implicit ctx: Context): T =

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

@@ -493,32 +493,34 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
       val expansion1 = InlineTyper.typed(expansion, pt)(inlineCtx)
 
       /** Does given definition bind a closure that will be inlined? */
-      def bindsDeadClosure(defn: ValOrDefDef) = Ident(defn.symbol.termRef) match {
-        case InlineableClosure(_) => !InlineTyper.retainedClosures.contains(defn.symbol)
+      def bindsDeadInlineable(defn: ValOrDefDef) = Ident(defn.symbol.termRef) match {
+        case InlineableArg(_) => !InlineTyper.retainedInlineables.contains(defn.symbol)
         case _ => false
       }
 
       /** All bindings in `bindingsBuf` except bindings of inlineable closures */
-      val bindings = bindingsBuf.toList.filterNot(bindsDeadClosure).map(_.withPos(call.pos))
+      val bindings = bindingsBuf.toList.filterNot(bindsDeadInlineable).map(_.withPos(call.pos))
 
       tpd.Inlined(call, bindings, expansion1)
     }
   }
 
-  /** An extractor for references to closure arguments that refer to `@inline` methods */
-  private object InlineableClosure {
+  /** An extractor for references to inlineable arguments. These are :
+   *   - by-value arguments marked with `inline`
+   *   - all by-name arguments
+   */
+  private object InlineableArg {
     lazy val paramProxies = paramProxy.values.toSet
     def unapply(tree: Ident)(implicit ctx: Context): Option[Tree] =
-      if (paramProxies.contains(tree.tpe)) {
+      if (paramProxies.contains(tree.tpe))
         bindingsBuf.find(_.name == tree.name) match {
-          case Some(ddef: ValDef) if ddef.symbol.is(Inline) =>
-            ddef.rhs match {
-              case closure(_, meth, _) => Some(meth)
-              case _ => None
-            }
+          case Some(vdef: ValDef) if vdef.symbol.is(Inline) =>
+            Some(vdef.rhs.changeOwner(vdef.symbol, ctx.owner))
+          case Some(ddef: DefDef) =>
+            Some(ddef.rhs.changeOwner(ddef.symbol, ctx.owner))
           case _ => None
         }
-      } else None
+      else None
   }
 
   /** A typer for inlined code. Its purpose is:
@@ -530,16 +532,13 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
    */
   private object InlineTyper extends ReTyper {
 
-    var retainedClosures = Set[Symbol]()
+    var retainedInlineables = Set[Symbol]()
 
-    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context) = {
-      val tree1 = super.typedIdent(tree, pt)
-      tree1 match {
-        case InlineableClosure(_) => retainedClosures += tree.symbol
-        case _ =>
+    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context) =
+      tree.asInstanceOf[tpd.Tree] match {
+        case InlineableArg(rhs) => inlining.println(i"inline arg $tree -> $rhs"); rhs
+        case _ => super.typedIdent(tree, pt)
       }
-      tree1
-    }
 
     override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
       assert(tree.hasType, tree)
@@ -562,12 +561,13 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
       }
     }
 
-    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context) = tree.asInstanceOf[tpd.Tree] match {
-      case Apply(Select(InlineableClosure(fn), nme.apply), args) =>
-        inlining.println(i"reducing $tree with closure $fn")
-        typed(fn.appliedToArgs(args), pt)
-      case _ =>
-        super.typedApply(tree, pt)
-    }
+    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context) =
+      tree.asInstanceOf[tpd.Tree] match {
+        case Apply(Select(InlineableArg(closure(_, fn, _)), nme.apply), args) =>
+          inlining.println(i"reducing $tree with closure $fn")
+          typed(fn.appliedToArgs(args), pt)
+        case _ =>
+          super.typedApply(tree, pt)
+      }
   }
 }

compiler/src/dotty/tools/dotc/util/Stats.scala

@@ -46,11 +46,13 @@ import collection.mutable
   def trackTime[T](fn: String)(op: => T) =
     if (enabled) doTrackTime(fn)(op) else op
 
-  def doTrackTime[T](fn: String)(op: => T) =
+  def doTrackTime[T](fn: String)(op: => T) = {
+    def op1 = op
     if (monitored) {
       val start = System.nanoTime
-      try op finally record(fn, ((System.nanoTime - start) / 1000).toInt)
-    } else op
+      try op1 finally record(fn, ((System.nanoTime - start) / 1000).toInt)
+    } else op1
+  }
 
   class HeartBeat extends Thread() {
     @volatile private[Stats] var continue = true