Don't treat inline closures specially.

Rely on call-by-name parameters instead. Fix "unused defs" logic so
that referred-to cbn parameters are not eliminated.

Author: odersky

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

@@ -810,16 +810,11 @@ object desugar {
    *  ==>
    *      def $anonfun(params) = body
    *      Closure($anonfun)
-   *
-   *  If `inlineable` is true, tag $anonfun with an @inline annotation.
    */
-  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), inlineable: Boolean)(implicit ctx: Context) = {
-    var mods = synthetic | Artifact
-    if (inlineable) mods |= Inline
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree())(implicit ctx: Context) =
     Block(
-      DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(mods),
+      DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(synthetic | Artifact),
       Closure(Nil, Ident(nme.ANON_FUN), EmptyTree))
-  }
 
   /** If `nparams` == 1, expand partial function
    *

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

@@ -645,9 +645,8 @@ trait Checking {
       case tp: TermRef if tp.symbol.is(InlineParam) => // ok
       case tp => tp.widenTermRefExpr match {
         case tp: ConstantType if exprPurity(tree) >= purityLevel => // ok
-        case tp if defn.isFunctionType(tp) && exprPurity(tree) >= purityLevel => // ok
         case _ =>
-          if (!ctx.erasedTypes) ctx.error(em"$what must be a constant expression or a function", tree.pos)
+          if (!ctx.erasedTypes) ctx.error(em"$what must be a constant expression", tree.pos)
       }
     }
   }

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

@@ -218,6 +218,31 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
   private def newSym(name: Name, flags: FlagSet, info: Type): Symbol =
     ctx.newSymbol(ctx.owner, name, flags, info, coord = call.pos)
 
+  /** A binding for the parameter of an inlined method. This is a `val` def for
+   *  by-value parameters and a `def` def for by-name parameters. `val` defs inherit
+   *  inline annotations from their parameters. The generated `def` is appended
+   *  to `bindingsBuf`.
+   *  @param name        the name of the parameter
+   *  @param paramtp     the type of the parameter
+   *  @param arg         the argument corresponding to the parameter
+   *  @param bindingsBuf the buffer to which the definition should be appended
+   */
+  private def paramBindingDef(name: Name, paramtp: Type, arg: Tree,
+                              bindingsBuf: mutable.ListBuffer[ValOrDefDef]): ValOrDefDef = {
+    val argtpe = arg.tpe.dealias
+    def isByName = paramtp.dealias.isInstanceOf[ExprType]
+    val inlineFlag = if (paramtp.hasAnnotation(defn.InlineParamAnnot)) Inline else EmptyFlags
+    val (bindingFlags, bindingType) =
+      if (isByName) (Method, 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)
+    bindingsBuf += binding
+    binding
+  }
+
   /** Populate `paramBinding` and `bindingsBuf` by matching parameters with
    *  corresponding arguments. `bindingbuf` will be further extended later by
    *  proxies to this-references.
@@ -230,20 +255,9 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
       computeParamBindings(tp.resultType, Nil, argss)
     case tp: MethodType =>
       (tp.paramNames, tp.paramInfos, argss.head).zipped.foreach { (name, paramtp, arg) =>
-        def isByName = paramtp.dealias.isInstanceOf[ExprType]
         paramBinding(name) = arg.tpe.dealias match {
           case _: SingletonType if isIdempotentExpr(arg) => arg.tpe
-          case argtpe =>
-            val inlineFlag = if (paramtp.hasAnnotation(defn.InlineParamAnnot)) Inline else EmptyFlags
-            val (bindingFlags, bindingType) =
-              if (isByName) (inlineFlag | Method, 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)
-            bindingsBuf += binding
-            boundSym.termRef
+          case _ => paramBindingDef(name, paramtp, arg, bindingsBuf).symbol.termRef
         }
       }
       computeParamBindings(tp.resultType, targs, argss.tail)
@@ -265,7 +279,7 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
    *      The proxy is not yet entered in `bindingsBuf`; that will come later.
    *  2.  If given type refers to a parameter, make `paramProxy` refer to the entry stored
    *      in `paramNames` under the parameter's name. This roundabout way to bind parameter
-   *      references to proxies is done because  we not known a priori what the parameter
+   *      references to proxies is done because  we don't know a priori what the parameter
    *      references of a method are (we only know the method's type, but that contains TypeParamRefs
    *      and MethodParams, not TypeRefs or TermRefs.
    */
@@ -374,16 +388,15 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
       // The final expansion runs a typing pass over the inlined tree. See InlineTyper for details.
       val expansion1 = InlineTyper.typed(expansion, pt)(inlineCtx)
 
-      /** Does given definition bind a closure that will be inlined? */
-      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(bindsDeadInlineable).map(_.withPos(call.pos))
+      val bindings = bindingsBuf.toList.map(_.withPos(call.pos))
+
+      inlining.println(i"original bindings = $bindings%\n%")
+      inlining.println(i"original expansion = $expansion1")
 
-      tpd.Inlined(call, bindings, expansion1)
+      val (finalBindings, finalExpansion) = dropUnusedDefs(bindings, expansion1)
+
+      tpd.Inlined(call, finalBindings, finalExpansion)
     }
   }
 
@@ -414,8 +427,6 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
    */
   private object InlineTyper extends ReTyper {
 
-    var retainedInlineables = Set[Symbol]()
-
     override def ensureAccessible(tpe: Type, superAccess: Boolean, pos: Position)(implicit ctx: Context): Type = {
       tpe match {
         case tpe @ TypeRef(pre, _) if !tpe.symbol.isAccessibleFrom(pre, superAccess) =>
@@ -455,13 +466,103 @@ 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(InlineableArg(closure(_, 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) = {
+
+      def betaReduce(tree: Tree) = tree match {
+        case Apply(Select(cl @ closureDef(ddef), nme.apply), args) =>
+          ddef.tpe.widen match {
+            case mt: MethodType if ddef.vparamss.head.length == args.length =>
+              val bindingsBuf = new mutable.ListBuffer[ValOrDefDef]
+              val argSyms = (mt.paramNames, mt.paramInfos, args).zipped.map { (name, paramtp, arg) =>
+                arg.tpe.dealias match {
+                  case ref @ TermRef(NoPrefix, _) => ref.symbol
+                  case _ => paramBindingDef(name, paramtp, arg, bindingsBuf).symbol
+                }
+              }
+              val expander = new TreeTypeMap(
+                oldOwners = ddef.symbol :: Nil,
+                newOwners = ctx.owner :: Nil,
+                substFrom = ddef.vparamss.head.map(_.symbol),
+                substTo = argSyms)
+              Block(bindingsBuf.toList, expander.transform(ddef.rhs))
+            case _ => tree
+          }
+        case _ => tree
       }
+
+      betaReduce(super.typedApply(tree, pt))
+    }
+  }
+
+  /** 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)
+    }
   }
 }

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

@@ -417,7 +417,7 @@ class Typer extends Namer
 
   /** Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
    */
-  private def checkStableIdentPattern(tree: Tree, pt: Type)(implicit ctx: Context): Tree = {
+  private def checkStableIdentPattern(tree: Tree, pt: Type)(implicit ctx: Context): tree.type = {
     if (ctx.mode.is(Mode.Pattern) &&
         !tree.isType &&
         !pt.isInstanceOf[ApplyingProto] &&
@@ -915,8 +915,7 @@ class Typer extends Namer
             else cpy.ValDef(param)(
               tpt = untpd.TypeTree(
                 inferredParamType(param, protoFormal(i)).underlyingIfRepeated(isJava = false)))
-        val inlineable = pt.hasAnnotation(defn.InlineParamAnnot)
-        desugar.makeClosure(inferredParams, fnBody, resultTpt, inlineable)
+        desugar.makeClosure(inferredParams, fnBody, resultTpt)
       }
     typed(desugared, pt)
   }

tests/run/i4431/quoted_1.scala

@@ -1,5 +1,5 @@
 import scala.quoted._
 
 object Macros {
-  inline def h(inline f: Int => String): String = ~ '(f(42))
+  inline def h(f: => Int => String): String = ~ '(f(42))
 }

tests/run/inlineByName.scala

@@ -0,0 +1,37 @@
+object Test {
+
+  class Range(from: Int, end: Int) {
+    inline def foreach(op: => Int => Unit): Unit = {
+      var i = from
+      while (i < end) {
+        op(i)
+        i += 1
+      }
+    }
+  }
+  inline def twice(op: => Int => Unit): Unit = {
+    op(1)
+    op(2)
+  }
+  inline def thrice(op: => Unit): Unit = {
+    op
+    op
+    op
+  }
+
+  def main(args: Array[String]) = {
+    var j = 0
+    new Range(1, 10).foreach(j += _)
+    assert(j == 45, j)
+    twice { x => j = j - x }
+    thrice { j = j + 1 }
+    val f = new Range(1, 10).foreach
+    f(j -= _)
+    assert(j == 0, j)
+    new Range(1, 10).foreach { i1 =>
+      new Range(2, 11).foreach { i2 =>
+        j += i1 * i2
+      }
+    }
+  }
+}

tests/run/inlineForeach.scala

@@ -3,7 +3,7 @@ object Test {
   class Range(from: Int, end: Int) {
 
     inline
-    def foreach(inline op: Int => Unit): Unit = {
+    def foreach(op: => Int => Unit): Unit = {
       var i = from
       while (i < end) {
         op(i)
@@ -36,7 +36,7 @@ object Test {
   }
 
   implicit class intArrayOps(arr: Array[Int]) {
-    inline def foreach(inline op: Int => Unit): Unit = {
+    inline def foreach(op: => Int => Unit): Unit = {
       var i = 0
       while (i < arr.length) {
         op(arr(i))

tests/run/inlinedAssign.scala

@@ -1,6 +1,6 @@
 object Test {
 
-  inline def swap[T](x: T, inline x_= : T => Unit, y: T, inline y_= : T => Unit) = {
+  inline def swap[T](x: T, x_= : => T => Unit, y: T, y_= : => T => Unit) = {
     x_=(y)
     y_=(x)
   }

tests/run/lst/Lst.scala

@@ -25,7 +25,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
   def isEmpty = elems == null
   def nonEmpty = elems != null
 
-  inline def foreach(inline op: T => Unit): Unit = {
+  inline def foreach(op: => T => Unit): Unit = {
     def sharedOp(x: T) = op(x)
     elems match {
       case null =>
@@ -39,7 +39,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
   /** Like `foreach`, but completely inlines `op`, at the price of generating the code twice.
    *  Should be used only of `op` is small
    */
-  inline def foreachInlined(inline op: T => Unit): Unit = elems match {
+  inline def foreachInlined(op: => T => Unit): Unit = elems match {
     case null =>
     case elems: Arr => def elem(i: Int) = elems(i).asInstanceOf[T]
       var i = 0
@@ -60,7 +60,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
   }
 
   /** `f` is pulled out, not duplicated */
-  inline def map[U](inline f: T => U): Lst[U] = {
+  inline def map[U](f: => T => U): Lst[U] = {
     def op(x: T) = f(x)
     elems match {
       case null => Empty
@@ -144,7 +144,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
   }
   def filterNot(p: T => Boolean): Lst[T] = filter(!p(_))
 
-  inline def exists(inline p: T => Boolean): Boolean = {
+  inline def exists(p: => T => Boolean): Boolean = {
     def op(x: T) = p(x)
     elems match {
       case null => false
@@ -157,7 +157,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
     }
   }
 
-  inline def forall(inline p: T => Boolean): Boolean = {
+  inline def forall(p: => T => Boolean): Boolean = {
     def op(x: T) = p(x)
     elems match {
       case null => true
@@ -180,7 +180,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
       elem == x
   }
 
-  inline def foldLeft[U](z: U)(inline f: (U, T) => U) = {
+  inline def foldLeft[U](z: U)(f: => (U, T) => U) = {
     def op(x: U, y: T) = f(x, y)
     elems match {
       case null => z
@@ -194,7 +194,7 @@ class Lst[+T](val elems: Any) extends AnyVal {
     }
   }
 
-  inline def /: [U](z: U)(inline op: (U, T) => U) = foldLeft(z)(op)
+  inline def /: [U](z: U)(op: => (U, T) => U) = foldLeft(z)(op)
 
   def reduceLeft[U >: T](op: (U, U) => U) = elems match {
     case elems: Arr => def elem(i: Int) = elems(i).asInstanceOf[T]