Avoid infix operations with more than one argument on the right. The

idiom

    x op (y, z)

will in the future be interpreted as taking a tuple `(y, z)`. So all
infix operations with more than one parameter have to be rewritten to
method calls. This was for the most part done using an automatic rewrite
(introduced in one of the next commits). Most of the tests were not re-formatted
afterwards so one sees the traces of the rewrite. E.g. the reqrite would yield

    x .op (y, z)

instead of the more idiomatic

    x.op(y. z)

Author: odersky

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -553,7 +553,7 @@ object Denotations {
           val r = mergeDenot(this, that)
           if (r.exists) r else MultiDenotation(this, that)
         case that @ MultiDenotation(denot1, denot2) =>
-          this & (denot1, pre) & (denot2, pre)
+          this .& (denot1, pre) .& (denot2, pre)
       }
     }
 
@@ -634,11 +634,11 @@ object Denotations {
       else if (!that.exists) that
       else this match {
         case denot1 @ MultiDenotation(denot11, denot12) =>
-          denot1.derivedUnionDenotation(denot11 | (that, pre), denot12 | (that, pre))
+          denot1.derivedUnionDenotation(denot11 .| (that, pre), denot12 .| (that, pre))
         case denot1: SingleDenotation =>
           that match {
             case denot2 @ MultiDenotation(denot21, denot22) =>
-              denot2.derivedUnionDenotation(this | (denot21, pre), this | (denot22, pre))
+              denot2.derivedUnionDenotation(this .| (denot21, pre), this .| (denot22, pre))
             case denot2: SingleDenotation =>
               unionDenot(denot1, denot2)
           }
@@ -1180,7 +1180,7 @@ object Denotations {
   final case class DenotUnion(denot1: PreDenotation, denot2: PreDenotation) extends MultiPreDenotation {
     def exists = true
     def toDenot(pre: Type)(implicit ctx: Context) =
-      (denot1 toDenot pre) & (denot2 toDenot pre, pre)
+      (denot1 toDenot pre) .& (denot2 toDenot pre, pre)
     def containsSym(sym: Symbol) =
       (denot1 containsSym sym) || (denot2 containsSym sym)
     type AsSeenFromResult = PreDenotation
@@ -1218,8 +1218,8 @@ object Denotations {
     def hasAltWith(p: SingleDenotation => Boolean): Boolean =
       denot1.hasAltWith(p) || denot2.hasAltWith(p)
     def accessibleFrom(pre: Type, superAccess: Boolean)(implicit ctx: Context): Denotation = {
-      val d1 = denot1 accessibleFrom (pre, superAccess)
-      val d2 = denot2 accessibleFrom (pre, superAccess)
+      val d1 = denot1.accessibleFrom(pre, superAccess)
+      val d2 = denot2.accessibleFrom(pre, superAccess)
       if (!d1.exists) d2
       else if (!d2.exists) d1
       else derivedUnionDenotation(d1, d2)

compiler/src/dotty/tools/dotc/core/NameOps.scala

@@ -121,7 +121,7 @@ object NameOps {
 
     /** If flags is a ModuleClass but not a Package, add module class suffix */
     def adjustIfModuleClass(flags: Flags.FlagSet): N = likeSpaced {
-      if (flags is (ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
+      if (flags.is(ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
       else name.toTermName.exclude(AvoidClashName)
     }
 

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -190,7 +190,7 @@ object SymDenotations {
      *  in `butNot` are set?
      */
     final def is(fs: FlagSet, butNot: FlagSet)(implicit ctx: Context) =
-      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
+      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).is(fs, butNot)
 
     /** Has this denotation all of the flags in `fs` set? */
     final def is(fs: FlagConjunction)(implicit ctx: Context) =
@@ -200,7 +200,7 @@ object SymDenotations {
      *  in `butNot` are set?
      */
     final def is(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context) =
-      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
+      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags).is(fs, butNot)
 
     /** The type info.
      *  The info is an instance of TypeType iff this is a type denotation
@@ -457,13 +457,13 @@ object SymDenotations {
     /** Is symbol known to not exist, or potentially not completed yet? */
     final def unforcedIsAbsent(implicit ctx: Context): Boolean =
       myInfo == NoType ||
-      (this is (ModuleVal, butNot = Package)) && moduleClass.unforcedIsAbsent
+      (this.is(ModuleVal, butNot = Package)) && moduleClass.unforcedIsAbsent
 
     /** Is symbol known to not exist? */
     final def isAbsent(implicit ctx: Context): Boolean = {
       ensureCompleted()
       (myInfo `eq` NoType) ||
-      (this is (ModuleVal, butNot = Package)) && moduleClass.isAbsent
+      (this.is(ModuleVal, butNot = Package)) && moduleClass.isAbsent
     }
 
     /** Is this symbol the root class or its companion object? */
@@ -921,7 +921,7 @@ object SymDenotations {
      *  A local dummy owner is mapped to the primary constructor of the class.
      */
     final def enclosingMethod(implicit ctx: Context): Symbol =
-      if (this is (Method, butNot = Label)) symbol
+      if (this.is(Method, butNot = Label)) symbol
       else if (this.isClass) primaryConstructor
       else if (this.exists) owner.enclosingMethod
       else NoSymbol
@@ -1352,7 +1352,7 @@ object SymDenotations {
 
     // ----- denotation fields and accessors ------------------------------
 
-    if (initFlags is (Module, butNot = Package))
+    if (initFlags.is(Module, butNot = Package))
       assert(name.is(ModuleClassName), s"module naming inconsistency: ${name.debugString}")
 
     /** The symbol asserted to have type ClassSymbol */

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -601,7 +601,7 @@ object Types {
             else pdenot.info recoverable_& rinfo
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         } else {
-          pdenot & (
+          pdenot .& (
             new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId)),
             pre,
             safeIntersection = ctx.pendingMemberSearches.contains(name))
@@ -646,7 +646,7 @@ object Types {
       }
 
       def goAnd(l: Type, r: Type) = {
-        go(l) & (go(r), pre, safeIntersection = ctx.pendingMemberSearches.contains(name))
+        go(l) .& (go(r), pre, safeIntersection = ctx.pendingMemberSearches.contains(name))
       }
 
       val recCount = ctx.findMemberCount
@@ -983,7 +983,7 @@ object Types {
           case res => res
         }
       case tp @ AndType(tp1, tp2) =>
-        tp derived_& (tp1.widenUnion, tp2.widenUnion)
+        tp.derived_&(tp1.widenUnion, tp2.widenUnion)
       case tp: RefinedType =>
         tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
       case tp: RecType =>

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

@@ -152,7 +152,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
       override def transform(tree: Tree)(implicit ctx: Context): Tree = tree match {
         case Ident(_) | Select(This(_), _) =>
           var sym = tree.symbol
-          if (sym is (ParamAccessor, butNot = Mutable)) sym = sym.subst(accessors, paramSyms)
+          if (sym.is(ParamAccessor, butNot = Mutable)) sym = sym.subst(accessors, paramSyms)
           if (sym.owner.isConstructor) ref(sym).withPos(tree.pos) else tree
         case Apply(fn, Nil) =>
           val fn1 = transform(fn)

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

@@ -48,7 +48,7 @@ class ParamForwarding(thisPhase: DenotTransformer) {
          * }
          */
         val candidate = sym.owner.asClass.superClass
-          .info.decl(sym.name).suchThat(_ is (ParamAccessor, butNot = Mutable)).symbol
+          .info.decl(sym.name).suchThat(_.is(ParamAccessor, butNot = Mutable)).symbol
         if (candidate.isAccessibleFrom(currentClass.thisType, superAccess = true)) candidate
         else if (candidate.exists) inheritedAccessor(candidate)
         else NoSymbol

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

@@ -123,7 +123,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
         // SI-4989 Check if an intermediate class between `clazz` and `sym.owner` redeclares the method as abstract.
         for (intermediateClass <- clazz.info.baseClasses.tail.takeWhile(_ != sym.owner)) {
           val overriding = sym.overridingSymbol(intermediateClass)
-          if ((overriding is (Deferred, butNot = AbsOverride)) && !(overriding.owner is Trait))
+          if (overriding.is(Deferred, butNot = AbsOverride) && !overriding.owner.is(Trait))
             ctx.error(
                 s"${sym.showLocated} cannot be directly accessed from ${clazz} because ${overriding.owner} redeclares it as abstract",
                 sel.pos)

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

@@ -26,7 +26,7 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
 
   /** If denotation had an ExprType before, it now gets a function type */
   protected def exprBecomesFunction(symd: SymDenotation)(implicit ctx: Context) =
-    (symd is Param) || (symd is (ParamAccessor, butNot = Method))
+    symd.is(Param) || symd.is(ParamAccessor, butNot = Method)
 
   protected def isByNameRef(tree: Tree)(implicit ctx: Context) = {
     val origDenot = originalDenotation(tree)

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

@@ -1029,7 +1029,7 @@ class Namer { typer: Typer =>
   def moduleValSig(sym: Symbol)(implicit ctx: Context): Type = {
     val clsName = sym.name.moduleClassName
     val cls = ctx.denotNamed(clsName) suchThat (_ is ModuleClass)
-    ctx.owner.thisType select (clsName, cls)
+    ctx.owner.thisType.select(clsName, cls)
   }
 
   /** The type signature of a ValDef or DefDef

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

@@ -151,7 +151,7 @@ class Typer extends Namer
     def qualifies(denot: Denotation): Boolean =
       reallyExists(denot) &&
         !(pt.isInstanceOf[UnapplySelectionProto] &&
-          (denot.symbol is (Method, butNot = Accessor))) &&
+          (denot.symbol.is(Method, butNot = Accessor))) &&
         !(denot.symbol is PackageClass)
 
     /** Find the denotation of enclosing `name` in given context `ctx`.

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

@@ -22,7 +22,7 @@ abstract class SimpleIdentityMap[K <: AnyRef, +V >: Null <: AnyRef] extends (K =
   def toList: List[(K, V)] = map2((k, v) => (k, v))
   override def toString = {
     def assocToString(key: K, value: V) = s"$key -> $value"
-    map2(assocToString) mkString ("(", ", ", ")")
+    map2(assocToString).mkString("(", ", ", ")")
   }
 }
 

compiler/src/dotty/tools/repl/terminal/filters/ReadlineFilters.scala

@@ -121,7 +121,7 @@ object ReadlineFilters {
     }
     def cutCharLeft(b: Vector[Char], c: Int) = {
       /* Do not edit current cut. Zsh(zle) & Bash(readline) do not edit the yank ring for Ctrl-h */
-      (b patch(from = c - 1, patch = Nil, replaced = 1), c - 1)
+      (b .patch(from = c - 1, patch = Nil, replaced = 1), c - 1)
     }
 
     def cutLineLeft(b: Vector[Char], c: Int) = {

tests/neg/i2033.scala

@@ -4,10 +4,10 @@ object Test {
   def check(obj: AnyRef): Unit = {
     val bos = new ByteArrayOutputStream()
     val out = new ObjectOutputStream(println) // error
-    val arr = bos toByteArray ()
+    val arr = bos.toByteArray ()
     val in = (())
     val deser = ()
-    val lhs = mutable LinkedHashSet ()
+    val lhs = mutable.LinkedHashSet ()
     check(lhs)
   }
 }

tests/run/collections.scala

@@ -18,7 +18,7 @@ object Test extends dotty.runtime.LegacyApp {
     println("***** "+msg+":")
     var s = s0
     s = s + 2
-    s = s + (3, 4000, 10000)
+    s = s.+(3, 4000, 10000)
     println("test1: "+sum(s))
     time {
       s = s ++ (List.range(0, iters) map (2*))
@@ -36,7 +36,7 @@ object Test extends dotty.runtime.LegacyApp {
     println("***** "+msg+":")
     var s = s0
     s = s + 2
-    s = s + (3, 4000, 10000)
+    s = s.+(3, 4000, 10000)
     println("test1: "+sum(s))
     time {
       s = s ++ (List.range(0, iters) map (2*))
@@ -54,7 +54,7 @@ object Test extends dotty.runtime.LegacyApp {
     println("***** "+msg+":")
     var s = s0
     s = s + (2 -> 2)
-    s = s + (3 -> 3, 4000 -> 4000, 10000 -> 10000)
+    s = s.+(3 -> 3, 4000 -> 4000, 10000 -> 10000)
     println("test1: "+sum(s map (_._2)))
     time {
       s = s ++ (List.range(0, iters) map (x => x * 2 -> x * 2))
@@ -89,7 +89,7 @@ object Test extends dotty.runtime.LegacyApp {
     println("***** "+msg+":")
     var s = s0
     s = s + (2 -> 2)
-    s = s + (3 -> 3, 4000 -> 4000, 10000 -> 10000)
+    s = s.+(3 -> 3, 4000 -> 4000, 10000 -> 10000)
     println("test1: "+sum(s map (_._2)))
     time {
       s = s ++ (List.range(0, iters) map (x => x * 2 -> x * 2))

tests/run/colltest1.scala

@@ -47,8 +47,8 @@ object Test extends dotty.runtime.LegacyApp {
     assert(vs1 == ten)
     assert((ten take 5) == firstFive)
     assert((ten drop 5) == secondFive)
-    assert(ten slice (3, 3) isEmpty)
-    assert((ten slice (3, 6)) == List(4, 5, 6), ten slice (3, 6))
+    assert(ten.slice(3, 3) isEmpty)
+    assert((ten.slice(3, 6)) == List(4, 5, 6), ten .slice (3, 6))
     assert((ten takeWhile (_ <= 5)) == firstFive)
     assert((ten dropWhile (_ <= 5)) == secondFive)
     assert((ten span (_ <= 5)) == (firstFive, secondFive))
@@ -139,7 +139,7 @@ object Test extends dotty.runtime.LegacyApp {
 
   def setTest(empty: => Set[String]): Unit = {
     var s = empty + "A" + "B" + "C"
-    s += ("D", "E", "F")
+    s = s.+("D", "E", "F")
     s ++= List("G", "H", "I")
     s ++= ('J' to 'Z') map (_.toString)
     assert(s forall (s contains))
@@ -156,8 +156,8 @@ object Test extends dotty.runtime.LegacyApp {
     assert(!s.isEmpty)
     val s1 = s intersect empty
     assert(s1 == empty, s1)
-    def abc = empty + ("a", "b", "c")
-    def bc = empty + ("b", "c")
+    def abc = empty.+("a", "b", "c")
+    def bc = empty.+("b", "c")
     assert(bc subsetOf abc)
   }
 
@@ -173,7 +173,7 @@ object Test extends dotty.runtime.LegacyApp {
 
   def mapTest(empty: => Map[String, String]) = {
     var m = empty + ("A" -> "A") + ("B" -> "B") + ("C" -> "C")
-    m += (("D" -> "D"), ("E" -> "E"), ("F" -> "F"))
+    m = m.+(("D" -> "D"), ("E" -> "E"), ("F" -> "F"))
     m ++= List(("G" -> "G"), ("H" -> "H"), ("I" -> "I"))
     m ++= ('J' to 'Z') map (x => (x.toString -> x.toString))
     println(m.toList.sorted)

tests/run/runtime.scala

@@ -65,15 +65,15 @@ object Test1Test {
     // {System.out.print(12); java.lang}.System.out.println();
     // {System.out.print(13); java.lang.System}.out.println();
     {Console.print(14); Console}.println;
-    {Console.print(15); (() => Console.println):(() => Unit)} apply ();
+    {Console.print(15); (() => Console.println):(() => Unit)} .apply ();
     {Console.print(16); Console.println};
 
     {Console.print(20)}; test1.bar.System.out.println();
     // {System.out.print(21); test1}.bar.System.out.println();
     // {System.out.print(22); test1.bar}.System.out.println();
     {Console.print(23); test1.bar.System}.out.println();
     {Console.print(24); test1.bar.System.out}.println();
-    {Console.print(25); test1.bar.System.out.println:(() => Unit)} apply ();
+    {Console.print(25); test1.bar.System.out.println:(() => Unit)} .apply ();
     {Console.print(26); test1.bar.System.out.println()};
   }
 

tests/run/t2544.scala

@@ -11,10 +11,10 @@ object Test {
   )
 
   def main(args: Array[String]) = {
-    println(Foo indexWhere(_ >= 2,1))
-    println(Foo.toList indexWhere(_ >= 2,1))
-    println(Foo segmentLength(_ <= 3,1))
-    println(Foo.toList segmentLength(_ <= 3,1))
+    println(Foo .indexWhere(_ >= 2,1))
+    println(Foo.toList .indexWhere(_ >= 2,1))
+    println(Foo .segmentLength(_ <= 3,1))
+    println(Foo.toList .segmentLength(_ <= 3,1))
     lengthEquiv(Foo lengthCompare 7)
     lengthEquiv(Foo.toList lengthCompare 7)
     lengthEquiv(Foo lengthCompare 2)

tests/run/t4813.scala

@@ -31,7 +31,7 @@ object Test extends dotty.runtime.LegacyApp {
   runTest(TreeSet(1,2,3))(_.clone) { buf => buf add 4 }
 
   // Maps
-  runTest(HashMap(1->1,2->2,3->3))(_.clone) { buf => buf put (4,4) }
-  runTest(WeakHashMap(1->1,2->2,3->3))(_.clone) { buf => buf put (4,4) }
+  runTest(HashMap(1->1,2->2,3->3))(_.clone) { buf => buf.put(4,4) }
+  runTest(WeakHashMap(1->1,2->2,3->3))(_.clone) { buf => buf.put(4,4) }
 }
 

tests/run/t5045.scala

@@ -6,7 +6,7 @@ object Test extends dotty.runtime.LegacyApp {
  import scala.util.matching.{ Regex, UnanchoredRegex }
 
  val dateP1 = """(\d\d\d\d)-(\d\d)-(\d\d)""".r.unanchored
- val dateP2 = """(\d\d\d\d)-(\d\d)-(\d\d)""" r ("year", "month", "day") unanchored
+ val dateP2 = """(\d\d\d\d)-(\d\d)-(\d\d)""" .r ("year", "month", "day") unanchored
  val dateP3 =  new Regex("""(\d\d\d\d)-(\d\d)-(\d\d)""", "year", "month", "day") with UnanchoredRegex
 
  val yearStr = "2011"

tests/run/t6271.scala

@@ -21,7 +21,7 @@ object Test extends dotty.runtime.LegacyApp {
   }
   def slicedIssue = {
     val viewed : Iterable[Iterable[Int]] = List(List(0).view).view
-    val filtered = viewed flatMap { x => List( x slice (2,3) ) }
+    val filtered = viewed flatMap { x => List( x.slice(2,3) ) }
     filtered.iterator.toIterable.flatten
   }
   filterIssue

tests/run/t6827.scala

@@ -10,7 +10,7 @@ object Test extends App {
     } catch {
       case e: Exception => e.toString
     }
-    println("%s: %s" format (label, status))
+    println("%s: %s".format(label, status))
   }
 
   tryit("start at -5", -5, 10)