Fix inlining of right-associative transparent methods

The stricter rules that transparent methods must be inlined revealed
that right-associative curried methods such as /: were never inlined.
To fix this:

 - take Blocks into account when deciding whether a tree is inlineable
 - fix typedApply, so that Blocks are moved outwards over curried applications
 - fix inlineCall so that we inline inside a block

Author: odersky

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

@@ -738,7 +738,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         }
 
       fun1.tpe match {
-        case err: ErrorType => untpd.cpy.Apply(tree)(fun1, proto.typedArgs).withType(err)
+        case err: ErrorType => cpy.Apply(tree)(fun1, proto.typedArgs).withType(err)
         case TryDynamicCallType => typedDynamicApply(tree, pt)
         case _ =>
           if (originalProto.isDropped) fun1
@@ -777,27 +777,34 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       wrapDefs(liftedDefs, typed(assign))
     }
 
-    if (untpd.isOpAssign(tree))
-      tryEither {
-        implicit ctx => realApply
-      } { (failedVal, failedState) =>
+    val app1 =
+      if (untpd.isOpAssign(tree))
         tryEither {
-          implicit ctx => typedOpAssign
-        } { (_, _) =>
-          failedState.commit()
-          failedVal
+          implicit ctx => realApply
+        } { (failedVal, failedState) =>
+          tryEither {
+            implicit ctx => typedOpAssign
+          } { (_, _) =>
+            failedState.commit()
+            failedVal
+          }
         }
+      else {
+        val app = realApply
+        app match {
+          case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
+            val op = fn.symbol
+            if (op == defn.Any_== || op == defn.Any_!=)
+              checkCanEqual(left.tpe.widen, right.tpe.widen, app.pos)
+          case _ =>
+        }
+        app
       }
-    else {
-      val app = realApply
-      app match {
-        case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
-          val op = fn.symbol
-          if (op == defn.Any_== || op == defn.Any_!=)
-            checkCanEqual(left.tpe.widen, right.tpe.widen, app.pos)
-        case _ =>
-      }
-      app
+    app1 match {
+      case Apply(Block(stats, fn), args) =>
+        tpd.cpy.Block(app1)(stats, tpd.cpy.Apply(app1)(fn, args))
+      case _ =>
+        app1
     }
   }
 

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

@@ -67,6 +67,12 @@ object Inliner {
     hasBodyToInline(meth) && !suppressInline
   }
 
+  /** Should call be inlined in this context? */
+  def isInlineable(tree: Tree)(implicit ctx: Context): Boolean = tree match {
+    case Block(_, expr) => isInlineable(expr)
+    case _ => isInlineable(tree.symbol)
+  }
+
   /** Is `meth` a transparent method that should be inlined in this context? */
   def isTransparentInlineable(meth: Symbol)(implicit ctx: Context): Boolean =
     meth.isTransparentInlineable && isInlineable(meth)
@@ -79,8 +85,10 @@ object Inliner {
    *  @return   An `Inlined` node that refers to the original call and the inlined bindings
    *            and body that replace it.
    */
-  def inlineCall(tree: Tree, pt: Type)(implicit ctx: Context): Tree =
-    if (enclosingInlineds.length < ctx.settings.XmaxInlines.value) {
+  def inlineCall(tree: Tree, pt: Type)(implicit ctx: Context): Tree = tree match {
+    case Block(stats, expr) =>
+      cpy.Block(tree)(stats, inlineCall(expr, pt))
+    case _ if (enclosingInlineds.length < ctx.settings.XmaxInlines.value) =>
       val body = bodyToInline(tree.symbol) // can typecheck the tree and thereby produce errors
       if (ctx.reporter.hasErrors) tree
       else {
@@ -89,14 +97,15 @@ object Inliner {
           else ctx.fresh.setProperty(InlineBindings, newMutableSymbolMap[Tree])
         new Inliner(tree, body)(inlinerCtx).inlined(pt)
       }
-    }
-    else errorTree(
-      tree,
-      i"""|Maximal number of successive inlines (${ctx.settings.XmaxInlines.value}) exceeded,
-          |Maybe this is caused by a recursive transparent method?
-          |You can use -Xmax:inlines to change the limit.""",
-      (tree :: enclosingInlineds).last.pos
-    )
+    case _ =>
+      errorTree(
+        tree,
+        i"""|Maximal number of successive inlines (${ctx.settings.XmaxInlines.value}) exceeded,
+            |Maybe this is caused by a recursive transparent method?
+            |You can use -Xmax:inlines to change the limit.""",
+        (tree :: enclosingInlineds).last.pos
+      )
+  }
 
   /** Replace `Inlined` node by a block that contains its bindings and expansion */
   def dropInlined(inlined: tpd.Inlined)(implicit ctx: Context): Tree = {

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

@@ -2378,7 +2378,7 @@ class Typer extends Namer
         checkEqualityEvidence(tree, pt)
         tree
       }
-      else if (Inliner.isInlineable(tree.symbol)) {
+      else if (Inliner.isInlineable(tree)) {
         tree.tpe <:< wildApprox(pt)
         readaptSimplified(Inliner.inlineCall(tree, pt))
       }