New scheme for infix operators

 - An infix operation `x op (y, z)` now unconditionally interprets
   `(y, z)` as a tuple, unless in Scala-2 mode.
 - In Scala-2 mode, the pattern will give a migration warning with
   option to rewrite in most cases. Excluded from rewrite are
   operator assignments and right-associative infix operations.
 - Auto-tupling is only enabled in `Scala-2` mode, and will give
   a migration warning with option to rewrite in that mode.

Author: odersky

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

@@ -776,18 +776,16 @@ object desugar {
     *                ==>    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 {
+
+    def assignToNamedArg(arg: Tree): Tree = arg match {
       case Assign(Ident(name), rhs) => cpy.NamedArg(arg)(name, rhs)
+      case Parens(arg1) => untpd.cpy.Parens(arg)(assignToNamedArg(arg1))
+      case Tuple(args) => untpd.cpy.Tuple(arg)(args.mapConserve(assignToNamedArg))
       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)
-    }
+
+    def makeOp(fn: Tree, arg: Tree, selectPos: Position) =
+      Apply(Select(fn, op.name).withPos(selectPos), assignToNamedArg(arg))
 
     if (isLeftAssoc(op.name))
       makeOp(left, right, Position(left.pos.start, op.pos.end, op.pos.start))

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -481,7 +481,7 @@ object Erasure {
 	/** Besides normal typing, this method collects all arguments
 	 *  to a compacted function into a single argument of array type.
 	 */
-    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
+    override def typedApply(tree: untpd.Apply, pt: Type, scala2InfixOp: Boolean)(implicit ctx: Context): Tree = {
       val Apply(fun, args) = tree
       if (fun.symbol == defn.cbnArg)
         typedUnadapted(args.head, pt)

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

@@ -23,6 +23,7 @@ import StdNames._
 import NameKinds.DefaultGetterName
 import ProtoTypes._
 import Inferencing._
+import rewrite.Rewrites.patch
 
 import collection.mutable
 import config.Printers.{overload, typr, unapp}
@@ -242,7 +243,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def success = ok
 
     protected def methodType = methType.asInstanceOf[MethodType]
-    private def methString: String = i"${methRef.symbol}: ${methType.show}"
+    private def methString: String = i"${methRef.symbol.showLocated}: ${methType.show}"
 
     /** Re-order arguments to correctly align named arguments */
     def reorder[T >: Untyped](args: List[Trees.Tree[T]]): List[Trees.Tree[T]] = {
@@ -669,10 +670,19 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  or, if application is an operator assignment, also an `Assign` or
    *  Block node.
    */
-  def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
-
+  def typedApply(tree: untpd.Apply, pt: Type, scala2InfixOp: Boolean = false)(implicit ctx: Context): Tree = {
     def realApply(implicit ctx: Context): Tree = track("realApply") {
-      val originalProto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
+      var originalProto = new FunProto(tree.args, IgnoredProto(pt), this)(argCtx(tree))
+
+      // In an infix operation `x op (y, z)` under Scala-2 mode, rewrite tuple on the
+      // right hand side to multi-parameters, i.e `x.op(y, z)`, relying on auto-tupling
+      // to revert this if `op` takes a single argument.
+      tree.args match {
+        case untpd.Tuple(elems) :: Nil if scala2InfixOp =>
+          originalProto = new FunProto(elems, IgnoredProto(pt), this)(argCtx(tree))
+          originalProto.scala2InfixOp = true
+        case _ =>
+      }
       val fun1 = typedExpr(tree.fun, originalProto)
 
       // Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as
@@ -682,7 +692,41 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       // otherwise we would get possible cross-talk between different `adapt` calls using the same
       // prototype. A cleaner alternative would be to return a modified prototype from `adapt` together with
       // a modified tree but this would be more convoluted and less efficient.
-      val proto = if (originalProto.isTupled) originalProto.tupled else originalProto
+      // All of this is provisional in the long run, since it is only needed under Scala-2 mode.
+      val proto =
+        if (originalProto.isTupled) originalProto.tupled
+        else {
+          // If we see a multi-parameter infix operation `x op (y, z)` under Scala-2 mode,
+          // issue a migration warning and propose a rewrite to `x .op (y, z)` (or
+          // `(x) .op (y, z)` is `x` is itself an infix operation) where this is possible.
+          // Not possible are rewrites of operator assignments and right-associative operators.
+          tree.fun match {
+            case sel @ Select(qual, opName)
+            if originalProto.scala2InfixOp && !fun1.tpe.widen.isErroneous =>
+              val opEndOffset = sel.pos.point + opName.toString.length
+              val isOpAssign = ctx.source(opEndOffset) == '='
+              val isRightAssoc = !isLeftAssoc(opName)
+              val addendum =
+                if (isOpAssign) "\nThis requires a manual rewrite since it is part of an operator assignment."
+                else if (isRightAssoc) "\nThis requires a manual rewrite since the operator is right-associative."
+                else "\nThis can be fixed automatically using -rewrite."
+              ctx.migrationWarning(
+                em"""infix operator takes exactly one argument,
+                    |use method call syntax with `.` instead.$addendum""", fun1.pos)
+              val Select(qual, _) = tree.fun
+              if (!isOpAssign && !isRightAssoc) {
+                patch(Position(sel.pos.point), ".")
+                qual match {
+                  case qual: untpd.InfixOp =>
+                    patch(qual.pos.startPos, "(")
+                    patch(qual.pos.endPos, ")")
+                  case _ =>
+                }
+              }
+            case _ =>
+          }
+          originalProto
+        }
 
       // If some of the application's arguments are function literals without explicitly declared
       // parameter types, relate the normalized result type of the application with the
@@ -750,12 +794,25 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
      *     { val xs = es; e' = e' + args }
      */
     def typedOpAssign(implicit ctx: Context): Tree = track("typedOpAssign") {
-      val Apply(Select(lhs, name), rhss) = tree
+      val Apply(sel @ Select(lhs, name), rhss) = tree
       val lhs1 = typedExpr(lhs)
       val liftedDefs = new mutable.ListBuffer[Tree]
       val lhs2 = untpd.TypedSplice(LiftComplex.liftAssigned(liftedDefs, lhs1))
-      val assign = untpd.Assign(lhs2,
-          untpd.Apply(untpd.Select(lhs2, name.asSimpleName.dropRight(1)), rhss))
+      val opName = name.asSimpleName.dropRight(1)
+
+      // If original operation was an infix operation under Scala-2 mode, generate
+      // again an infix operation insteadof an application, so that the logic does
+      // the right thing for migrating from auto-tupling and multi-parameter infix ops.
+      val app = rhss match {
+        case (rhs: untpd.Tuple) :: Nil if scala2InfixOp =>
+          val opEndOffset = sel.pos.point + opName.length
+          assert(ctx.source(opEndOffset) == '=')
+          val op = untpd.Ident(opName).withPos(Position(sel.pos.point, opEndOffset))
+          untpd.InfixOp(lhs2, op, rhs)
+        case _ =>
+          untpd.Apply(untpd.Select(lhs2, opName), rhss)
+      }
+      val assign = untpd.Assign(lhs2, app)
       wrapDefs(liftedDefs, typed(assign))
     }
 

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

@@ -564,13 +564,13 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
       }
     }
 
-    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context) =
+    override def typedApply(tree: untpd.Apply, pt: Type, scala2InfixOp: Boolean)(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)
+          super.typedApply(tree, pt, scala2InfixOp)
       }
   }
 }

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

@@ -288,6 +288,11 @@ object ProtoTypes {
     def typeOfArg(arg: untpd.Tree)(implicit ctx: Context): Type =
       myTypedArg(arg).tpe
 
+    // `scala2InfixOp` and `tupled` only needed for Scala-2 compatibility and migration
+
+    /** FunProto applies to an infix operation under -language:Scala2 */
+    var scala2InfixOp = false
+
     private[this] var myTupled: Type = NoType
 
     /** The same proto-type but with all arguments combined in a single tuple */

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

@@ -1709,7 +1709,7 @@ class Typer extends Namer
    */
   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)
+    val app = typedApply(desugar.binop(l, op, r), pt, scala2InfixOp = ctx.scala2Mode)
     if (untpd.isLeftAssoc(op.name)) app
     else {
       val defs = new mutable.ListBuffer[Tree]
@@ -2037,22 +2037,13 @@ class Typer extends Namer
   def canAutoTuple(args: List[untpd.Tree])(implicit ctx: Context): Boolean = {
     val pos = Position(args.map(_.pos.start).min, args.map(_.pos.end).max)
     ctx.testScala2Mode(
-        i"""auto-tupling is no longer supported in this case,
-            |arguments now need to be enclosed in parentheses (...).""",
+        i"""auto-tupling is no longer supported,
+           |arguments now need to be enclosed in parentheses (...).""",
         pos, { patch(pos.startPos, "("); patch(pos.endPos, ")") })
   }
 
-  def takesAutoTupledArgs(tp: Type, sym: Symbol, args: List[untpd.Tree])(implicit ctx: Context): Boolean = tp match {
-    case tp: MethodicType =>
-      tp.firstParamTypes match {
-        case ptype :: Nil => !ptype.isRepeatedParam && (sym.name.isOpName || canAutoTuple(args))
-        case _ => false
-      }
-    case tp: TermRef =>
-      tp.denot.alternatives.forall(alt => takesAutoTupledArgs(alt.info, alt.symbol, args))
-    case _ =>
-      false
-  }
+  def takesAutoTupledArgs(tp: Type, pt: FunProto)(implicit ctx: Context): Boolean =
+    pt.args.lengthCompare(1) > 0 && isUnary(tp) && (pt.scala2InfixOp || canAutoTuple(pt.args))
 
   /** Perform the following adaptations of expression, pattern or type `tree` wrt to
    *  given prototype `pt`:
@@ -2143,10 +2134,8 @@ class Typer extends Namer
 
       def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
         case _: MethodOrPoly =>
-          if (pt.args.lengthCompare(1) > 0 && takesAutoTupledArgs(wtp, tree.symbol, pt.args))
-            adapt(tree, pt.tupled, locked)
-          else
-            tree
+          if (takesAutoTupledArgs(wtp, pt)) adapt(tree, pt.tupled, locked)
+          else tree
         case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
           errorTree(tree, MethodDoesNotTakeParameters(tree, methPart(tree).tpe)(err))
         }
@@ -2511,8 +2500,7 @@ class Typer extends Namer
           tree
         case ref: TermRef => // this case can happen in case tree.tpe is overloaded
           pt match {
-            case pt: FunProto
-            if pt.args.lengthCompare(1) > 0 && takesAutoTupledArgs(ref, ref.symbol, pt.args) =>
+            case pt: FunProto if takesAutoTupledArgs(ref, pt) =>
               adapt(tree, pt.tupled, locked)
             case _ =>
               adaptOverloaded(ref)