Fix #2808: Modify lifting of infix operations

Lift the left hand side of a right-associative infix operation
only if the operation takes a by-value argument.

Author: odersky

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

@@ -725,6 +725,31 @@ object desugar {
       tree
   }
 
+  /** Translate infix operation expression
+    *
+    *     l op r     ==>    l.op(r)  if op is left-associative
+    *                ==>    r.op(l)  if op is right-associative
+    */
+  def binop(left: Tree, op: Ident, right: Tree)(implicit ctx: Context): Apply = {
+      def assignToNamedArg(arg: Tree) = arg match {
+        case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
+        case _ => arg
+      }
+    def makeOp(fn: Tree, arg: Tree, selectPos: Position) = {
+      val args: List[Tree] = arg match {
+        case Parens(arg) => assignToNamedArg(arg) :: Nil
+        case Tuple(args) => args.mapConserve(assignToNamedArg)
+        case _ => arg :: Nil
+      }
+      Apply(Select(fn, op.name).withPos(selectPos), args)
+    }
+
+    if (isLeftAssoc(op.name))
+      makeOp(left, right, Position(left.pos.start, op.pos.end, op.pos.start))
+    else
+      makeOp(right, left, Position(op.pos.start, right.pos.end))
+  }
+
   /** Make closure corresponding to function.
    *      params => body
    *  ==>
@@ -832,30 +857,6 @@ object desugar {
       Block(ldef, call)
     }
 
-    /** Translate infix operation expression  left op right
-     */
-    def makeBinop(left: Tree, op: Ident, right: Tree): Tree = {
-      def assignToNamedArg(arg: Tree) = arg match {
-        case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
-        case _ => arg
-      }
-      if (isLeftAssoc(op.name)) {
-        val args: List[Tree] = right match {
-          case Parens(arg) => assignToNamedArg(arg) :: Nil
-          case Tuple(args) => args mapConserve assignToNamedArg
-          case _ => right :: Nil
-        }
-        val selectPos = Position(left.pos.start, op.pos.end, op.pos.start)
-        Apply(Select(left, op.name).withPos(selectPos), args)
-      } else {
-        val x = UniqueName.fresh()
-        val selectPos = Position(op.pos.start, right.pos.end, op.pos.start)
-        new InfixOpBlock(
-          ValDef(x, TypeTree(), left).withMods(synthetic),
-          Apply(Select(right, op.name).withPos(selectPos), Ident(x).withPos(left.pos)))
-      }
-    }
-
     /** Create tree for for-comprehension `<for (enums) do body>` or
      *   `<for (enums) yield body>` where mapName and flatMapName are chosen
      *  corresponding to whether this is a for-do or a for-yield.
@@ -1066,10 +1067,10 @@ object desugar {
           if (!op.isBackquoted && op.name == tpnme.raw.AMP) AndTypeTree(l, r)     // l & r
           else if (!op.isBackquoted && op.name == tpnme.raw.BAR) OrTypeTree(l, r) // l | r
           else AppliedTypeTree(op, l :: r :: Nil) // op[l, r]
-        else if (ctx.mode is Mode.Pattern)
+        else {
+          assert(ctx.mode is Mode.Pattern) // expressions are handled separately by `binop`
           Apply(op, l :: r :: Nil) // op(l, r)
-        else // l.op(r), or val x = r; l.op(x), plus handle named args specially
-          makeBinop(l, op, r)
+        }
       case PostfixOp(t, op) =>
         if ((ctx.mode is Mode.Type) && !op.isBackquoted && op.name == tpnme.raw.STAR) {
           val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType

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

@@ -1679,6 +1679,30 @@ class Typer extends Namer
     res
   }
 
+  /** Translate infix operation expression `l op r` to
+   *
+   *    l.op(r)   			    if `op` is left-associative
+   *    { val x = l; r.op(l) }  if `op` is right-associative call-by-value and `l` is impure
+   *    r.op(l)                 if `op` is right-associative call-by-name or `l` is pure
+   */
+  def typedInfixOp(tree: untpd.InfixOp, pt: Type)(implicit ctx: Context): Tree = {
+    val untpd.InfixOp(l, op, r) = tree
+    val app = typedApply(desugar.binop(l, op, r), pt)
+    if (untpd.isLeftAssoc(op.name)) app
+    else {
+      val defs = new mutable.ListBuffer[Tree]
+      def lift(app: Tree): Tree = (app: @unchecked) match {
+        case Apply(fn, args) =>
+          tpd.cpy.Apply(app)(fn, LiftImpure.liftArgs(defs, fn.tpe, args))
+        case Assign(lhs, rhs) =>
+          tpd.cpy.Assign(app)(lhs, lift(rhs))
+        case Block(stats, expr) =>
+          tpd.cpy.Block(app)(stats, lift(expr))
+      }
+      Applications.wrapDefs(defs, lift(app))
+    }
+  }
+
   /** Retrieve symbol attached to given tree */
   protected def retrieveSym(tree: untpd.Tree)(implicit ctx: Context) = tree.removeAttachment(SymOfTree) match {
     case Some(sym) =>
@@ -1765,6 +1789,7 @@ class Typer extends Namer
           case tree: untpd.TypedSplice => typedTypedSplice(tree)
           case tree: untpd.UnApply => typedUnApply(tree, pt)
           case tree: untpd.DependentTypeTree => typed(untpd.TypeTree().withPos(tree.pos), pt)
+          case tree: untpd.InfixOp if ctx.mode.isExpr => typedInfixOp(tree, pt)
           case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
           case untpd.EmptyTree => tpd.EmptyTree
           case _ => typedUnadapted(desugar(tree), pt)

tests/run/i2808.check

@@ -0,0 +1 @@
+foo

tests/run/i2808.scala

@@ -0,0 +1,14 @@
+class C {
+  def m1_:(f: Int) = ()
+  def m2_:(f: => Int) = ()
+}
+
+object Test {
+  def foo() = { println("foo") ; 5 }
+
+  def main(args: Array[String]): Unit = {
+    val c = new C
+    foo() m1_: c
+    foo() m2_: c
+  }
+}