Merge pull request scala#7841 from som-snytt/topic/clean-patmat

Reduce or eliminate postfixOps

Author: SethTisue

src/compiler/scala/tools/nsc/Global.scala

@@ -36,7 +36,6 @@ import transform.patmat.PatternMatching
 import transform._
 import backend.{JavaPlatform, ScalaPrimitives}
 import backend.jvm.{BackendStats, GenBCode}
-import scala.language.postfixOps
 import scala.tools.nsc.ast.{TreeGen => AstTreeGen}
 import scala.tools.nsc.classpath._
 import scala.tools.nsc.profile.Profiler
@@ -756,7 +755,7 @@ class Global(var currentSettings: Settings, reporter0: LegacyReporter)
   private def phaseHelp(title: String, elliptically: Boolean, describe: SubComponent => String): String = {
     val Limit   = 16    // phase names should not be absurdly long
     val MaxCol  = 80    // because some of us edit on green screens
-    val maxName = phaseNames map (_.length) max
+    val maxName = phaseNames.map(_.length).max
     val width   = maxName min Limit
     val maxDesc = MaxCol - (width + 6)  // descriptions not novels
     val fmt     = if (settings.verbose || !elliptically) s"%${maxName}s  %2s  %s%n"
@@ -806,13 +805,12 @@ class Global(var currentSettings: Settings, reporter0: LegacyReporter)
   /** Returns List of (phase, value) pairs, including only those
    *  where the value compares unequal to the previous phase's value.
    */
-  def afterEachPhase[T](op: => T): List[(Phase, T)] = { // used in tests
+  def afterEachPhase[T](op: => T): List[(Phase, T)] = // used in tests
     phaseDescriptors.map(_.ownPhase).filterNot(_ eq NoPhase).foldLeft(List[(Phase, T)]()) { (res, ph) =>
       val value = exitingPhase(ph)(op)
       if (res.nonEmpty && res.head._2 == value) res
       else ((ph, value)) :: res
-    } reverse
-  }
+    }.reverse
 
   // ------------ REPL utilities ---------------------------------
 
@@ -1420,7 +1418,7 @@ class Global(var currentSettings: Settings, reporter0: LegacyReporter)
           case -1   => mkName(str)
           case idx  =>
             val phasePart = str drop (idx + 1)
-            settings.Yshow.tryToSetColon(phasePart split ',' toList)
+            settings.Yshow.tryToSetColon(phasePart.split(',').toList)
             mkName(str take idx)
         }
       }
@@ -1699,7 +1697,7 @@ class Global(var currentSettings: Settings, reporter0: LegacyReporter)
     val syms = findMemberFromRoot(fullName) match {
       // The name as given was not found, so we'll sift through every symbol in
       // the run looking for plausible matches.
-      case NoSymbol => phased(currentRun.symSource.keys map (sym => findNamedMember(fullName, sym)) filterNot (_ == NoSymbol) toList)
+      case NoSymbol => phased(currentRun.symSource.keys.map(findNamedMember(fullName, _)).filterNot(_ == NoSymbol).toList)
       // The name as given matched, so show only that.
       case sym      => List(sym)
     }

src/compiler/scala/tools/nsc/Main.scala

@@ -13,14 +13,12 @@
 package scala.tools
 package nsc
 
-import scala.language.postfixOps
-
 /** The main class for NSC, a compiler for the programming
  *  language Scala.
  */
 class MainClass extends Driver with EvalLoop {
   def resident(compiler: Global): Unit = loop { line =>
-    val command = new CompilerCommand(line split "\\s+" toList, new Settings(scalacError))
+    val command = new CompilerCommand(line.split("\\s+").toList, new Settings(scalacError))
     compiler.reporter.reset()
     new compiler.Run() compile command.files
   }

src/compiler/scala/tools/nsc/PhaseAssembly.scala

@@ -13,7 +13,6 @@
 package scala.tools.nsc
 
 import scala.collection.mutable
-import scala.language.postfixOps
 
 /** Converts an unordered morass of components into an order that
  *  satisfies their mutual constraints.
@@ -99,7 +98,7 @@ trait PhaseAssembly {
      * names are sorted alphabetical at each level, into the compiler phase list
      */
     def compilerPhaseList(): List[SubComponent] =
-      nodes.values.toList filter (_.level > 0) sortBy (x => (x.level, x.phasename)) flatMap (_.phaseobj) flatten
+      nodes.values.toList.filter(_.level > 0).sortBy(x => (x.level, x.phasename)).flatMap(_.phaseobj).flatten
 
     /* Test if there are cycles in the graph, assign levels to the nodes
      * and collapse hard links into nodes

src/compiler/scala/tools/nsc/ast/NodePrinters.scala

@@ -15,7 +15,6 @@ package ast
 
 import java.lang.System.{lineSeparator => EOL}
 import symtab.Flags._
-import scala.language.postfixOps
 import scala.reflect.internal.util.ListOfNil
 
 /** The object `nodePrinter` converts the internal tree
@@ -67,8 +66,8 @@ abstract class NodePrinters {
     def showAttributes(tree: Tree): String = {
       if (infolevel == InfoLevel.Quiet) ""
       else {
-        try   { List(showSymbol(tree), showType(tree)) filterNot (_ == "") mkString ", " trim }
-        catch { case ex: Throwable => "sym= <error> " + ex.getMessage }
+        try List(showSymbol(tree), showType(tree)).filterNot(_ == "").mkString(", ").trim
+        catch { case ex: Throwable => s"sym= <error> ${ex.getMessage}" }
       }
     }
   }

src/compiler/scala/tools/nsc/ast/TreeDSL.scala

@@ -128,8 +128,10 @@ trait TreeDSL {
     }
     class TryStart(body: Tree, catches: List[CaseDef], fin: Tree) {
       def CATCH(xs: CaseDef*) = new TryStart(body, xs.toList, fin)
-      def ENDTRY              = Try(body, catches, fin)
+      def FINALLY(end: END.type) = Try(body, catches, fin)
+      def FINALLY(fin1: Tree) = Try(body, catches, fin1)
     }
+    object END
 
     def CASE(pat: Tree): CaseStart  = new CaseStart(pat, EmptyTree)
     def DEFAULT: CaseStart          = new CaseStart(Ident(nme.WILDCARD), EmptyTree)

src/compiler/scala/tools/nsc/ast/TreeGen.scala

@@ -15,7 +15,6 @@ package ast
 
 import scala.collection.mutable.ListBuffer
 import symtab.Flags._
-import scala.language.postfixOps
 import scala.reflect.internal.util.FreshNameCreator
 import scala.reflect.internal.util.ListOfNil
 
@@ -106,7 +105,7 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
   def mkAppliedTypeForCase(clazz: Symbol): Tree = {
     val numParams = clazz.typeParams.size
     if (clazz.typeParams.isEmpty) Ident(clazz)
-    else AppliedTypeTree(Ident(clazz), 1 to numParams map (_ => Bind(tpnme.WILDCARD, EmptyTree)) toList)
+    else AppliedTypeTree(Ident(clazz), (1 to numParams).map(_ => Bind(tpnme.WILDCARD, EmptyTree)).toList)
   }
   def mkBindForCase(patVar: Symbol, clazz: Symbol, targs: List[Type]): Tree = {
     Bind(patVar, Typed(Ident(nme.WILDCARD),

src/compiler/scala/tools/nsc/ast/parser/Scanners.scala

@@ -20,7 +20,6 @@ import Tokens._
 import scala.annotation.{switch, tailrec}
 import scala.collection.mutable, mutable.{ListBuffer, ArrayBuffer}
 import scala.tools.nsc.ast.parser.xml.Utility.isNameStart
-import scala.language.postfixOps
 
 /** See Parsers.scala / ParsersCommon for some explanation of ScannersCommon.
  */
@@ -1379,7 +1378,7 @@ trait Scanners extends ScannersCommon {
     /** The source code with braces and line starts annotated with [NN] showing the index */
     private def markedSource = {
       val code   = unit.source.content
-      val braces = code.indices filter (idx => "{}\n" contains code(idx)) toSet
+      val braces = code.indices.filter(idx => "{}\n" contains code(idx)).toSet
       val mapped = code.indices map (idx => if (braces(idx)) s"${code(idx)}[$idx]" else "" + code(idx))
       mapped.mkString("")
     }

src/compiler/scala/tools/nsc/io/Jar.scala

@@ -13,7 +13,6 @@
 package scala.tools.nsc
 package io
 
-import scala.language.postfixOps
 import java.io.{DataOutputStream, InputStream, OutputStream}
 import java.util.jar._
 
@@ -51,9 +50,9 @@ class Jar(file: File) extends AbstractIterable[JarEntry] {
   def mainClass     = manifest map (f => f(Name.MAIN_CLASS))
   /** The manifest-defined classpath String if available. */
   def classPathString: Option[String] =
-    for (m <- manifest ; cp <- m.attrs get Name.CLASS_PATH) yield cp
+    for (m <- manifest ; cp <- m.attrs.get(Name.CLASS_PATH)) yield cp
   def classPathElements: List[String] = classPathString match {
-    case Some(s)  => s split "\\s+" toList
+    case Some(s)  => s.split("\\s+").toList
     case _        => Nil
   }
 

src/compiler/scala/tools/nsc/symtab/SymbolTrackers.scala

@@ -14,7 +14,6 @@ package scala.tools.nsc
 package symtab
 
 import scala.language.implicitConversions
-import scala.language.postfixOps
 
 /** Printing the symbol graph (for those symbols attached to an AST node)
  *  after each phase.
@@ -176,8 +175,8 @@ trait SymbolTrackers {
       val change = Change(added, removed, prevMap, owners, flags)
 
       prevMap    = currentMap
-      prevOwners = current map (s => (s, s.owner)) toMap;
-      prevFlags  = current map (s => (s, (s.flags & flagsMask))) toMap;
+      prevOwners = current.map(s => (s, s.owner)).toMap
+      prevFlags  = current.map(s => (s, (s.flags & flagsMask))).toMap
       history    = change :: history
     }
     def show(label: String): String = {

src/compiler/scala/tools/nsc/transform/CleanUp.scala

@@ -16,7 +16,6 @@ package transform
 import symtab._
 import Flags._
 import scala.collection._
-import scala.language.postfixOps
 
 abstract class CleanUp extends Statics with Transform with ast.TreeDSL {
   import global._
@@ -269,7 +268,7 @@ abstract class CleanUp extends Statics with Transform with ast.TreeDSL {
               def catchBody   = Throw(Apply(Select(Ident(invokeExc), nme.getCause), Nil))
 
               // try { method.invoke } catch { case e: InvocationTargetExceptionClass => throw e.getCause() }
-              fixResult(TRY (invocation) CATCH { CASE (catchVar) ==> catchBody } ENDTRY)
+              fixResult(TRY (invocation) CATCH { CASE (catchVar) ==> catchBody } FINALLY END)
             }
 
             /* A possible primitive method call, represented by methods in BoxesRunTime. */

src/compiler/scala/tools/nsc/transform/patmat/Logic.scala

@@ -13,15 +13,14 @@
 package scala
 package tools.nsc.transform.patmat
 
-import scala.language.postfixOps
 import scala.collection.mutable
 import scala.collection.immutable.ArraySeq
 import scala.reflect.internal.util.{HashSet, NoPosition, Position, StatisticsStatics}
 
 trait Logic extends Debugging  {
   import global.statistics
 
-  private def max(xs: Seq[Int]) = if (xs isEmpty) 0 else xs max
+  private def max(xs: Seq[Int]) = if (xs.isEmpty) 0 else xs.max
   private def alignedColumns(cols: Seq[Any]): Seq[String] = {
     def toString(x: Any) = if (x == null) "" else x.toString
     if (cols.isEmpty || cols.tails.isEmpty) cols map toString

src/compiler/scala/tools/nsc/transform/patmat/MatchCodeGen.scala

@@ -12,8 +12,6 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.language.postfixOps
-
 import scala.tools.nsc.symtab.Flags.SYNTHETIC
 import scala.reflect.internal.util.Position
 
@@ -128,11 +126,11 @@ trait MatchCodeGen extends Interface {
         // must compute catchAll after caseLabels (side-effects nextCase)
         // catchAll.isEmpty iff no synthetic default case needed (the (last) user-defined case is a default)
         // if the last user-defined case is a default, it will never jump to the next case; it will go immediately to matchEnd
-        val catchAllDef = matchFailGen map { matchFailGen =>
+        val catchAllDef = matchFailGen.map { matchFailGen =>
           val scrutRef = scrutSym.fold(EmptyTree: Tree)(REF) // for alternatives
 
-          LabelDef(_currCase, Nil, matchEnd APPLY (matchFailGen(scrutRef)))
-        } toList // at most 1 element
+          LabelDef(_currCase, Nil, matchEnd APPLY matchFailGen(scrutRef))
+        }.toList // at most 1 element
 
         // scrutSym == NoSymbol when generating an alternatives matcher
         val scrutDef = scrutSym.fold(List[Tree]())(ValDef(_, scrut) :: Nil) // for alternatives

src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala

@@ -12,8 +12,6 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.language.postfixOps
-
 import scala.tools.nsc.symtab.Flags.MUTABLE
 import scala.collection.mutable
 import scala.reflect.internal.util.Position
@@ -62,7 +60,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
         if (conds(False)) false // stop when we encounter a definite "no" or a "not sure"
         else {
           val nonTrivial = conds - True
-          if (nonTrivial nonEmpty) {
+          if (!nonTrivial.isEmpty) {
             tested ++= nonTrivial
 
             // is there an earlier test that checks our condition and whose dependencies are implied by ours?
@@ -468,7 +466,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
           // a switch with duplicate cases yields a verify error,
           // and a switch with duplicate cases and guards cannot soundly be rewritten to an unguarded switch
           // (even though the verify error would disappear, the behaviour would change)
-          val allReachable = unreachableCase(caseDefsWithGuards) map (cd => reportUnreachable(cd.body.pos)) isEmpty
+          val allReachable = unreachableCase(caseDefsWithGuards).map(cd => reportUnreachable(cd.body.pos)).isEmpty
 
           if (!allReachable) Nil
           else if (noGuards(caseDefsWithGuards)) {
@@ -536,7 +534,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
       // TODO: if patterns allow switch but the type of the scrutinee doesn't, cast (type-test) the scrutinee to the corresponding switchable type and switch on the result
       if (regularSwitchMaker.switchableTpe(dealiasWiden(scrutSym.tpe))) {
         val caseDefsWithDefault = regularSwitchMaker(cases map {c => (scrutSym, c)}, pt)
-        if (caseDefsWithDefault isEmpty) None // not worth emitting a switch.
+        if (caseDefsWithDefault.isEmpty) None // not worth emitting a switch.
         else {
           // match on scrutSym -- converted to an int if necessary -- not on scrut directly (to avoid duplicating scrut)
           val scrutToInt: Tree =
@@ -586,7 +584,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
     // TODO: drop null checks
     override def emitTypeSwitch(bindersAndCases: List[(Symbol, List[TreeMaker])], pt: Type): Option[List[CaseDef]] = {
       val caseDefsWithDefault = typeSwitchMaker(bindersAndCases, pt)
-      if (caseDefsWithDefault isEmpty) None
+      if (caseDefsWithDefault.isEmpty) None
       else Some(caseDefsWithDefault)
     }
   }

src/compiler/scala/tools/nsc/transform/patmat/MatchTranslation.scala

@@ -12,10 +12,8 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.language.postfixOps
 import scala.reflect.internal.util.StatisticsStatics
 
-
 /** Translate typed Trees that represent pattern matches into the patternmatching IR, defined by TreeMakers.
  */
 trait MatchTranslation {
@@ -30,8 +28,6 @@ trait MatchTranslation {
   private def setVarInfo(sym: Symbol, info: Type) =
     sym setInfo debug.patmatResult(s"changing ${sym.defString} to")(repeatedToSeq(info))
 
-  private def hasSym(t: Tree) = t.symbol != null && t.symbol != NoSymbol
-
   trait MatchTranslator extends TreeMakers with TreeMakerWarnings {
     import typer.context
     def selectorPos: Position
@@ -62,8 +58,8 @@ trait MatchTranslation {
 
     object SymbolBound {
       def unapply(tree: Tree): Option[(Symbol, Tree)] = tree match {
-        case Bind(_, expr) if hasSym(tree) => Some(tree.symbol -> expr)
-        case _                             => None
+        case Bind(_, expr) if tree.hasExistingSymbol => Some(tree.symbol -> expr)
+        case _                                       => None
       }
     }
 
@@ -408,7 +404,7 @@ trait MatchTranslation {
       }
 
       // never store these in local variables (for PreserveSubPatBinders)
-      lazy val ignoredSubPatBinders: Set[Symbol] = subPatBinders zip args collect { case (b, PatternBoundToUnderscore()) => b } toSet
+      lazy val ignoredSubPatBinders: Set[Symbol] = (subPatBinders zip args).collect { case (b, PatternBoundToUnderscore()) => b }.toSet
 
       // there are `productArity` non-seq elements in the tuple.
       protected def firstIndexingBinder = productArity

src/compiler/scala/tools/nsc/transform/patmat/MatchTreeMaking.scala

@@ -12,8 +12,6 @@
 
 package scala.tools.nsc.transform.patmat
 
-import scala.language.postfixOps
-
 import scala.tools.nsc.symtab.Flags.{SYNTHETIC, ARTIFACT}
 import scala.collection.mutable
 import scala.reflect.internal.util.Position
@@ -632,7 +630,7 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging {
         emitSwitch(scrut, scrutSym, casesNoSubstOnly, pt, matchFailGenOverride, unchecked = suppression.suppressExhaustive).getOrElse{
           if (requireSwitch) reporter.warning(scrut.pos, "could not emit switch for @switch annotated match")
 
-          if (casesNoSubstOnly nonEmpty) {
+          if (!casesNoSubstOnly.isEmpty) {
             // before optimizing, check casesNoSubstOnly for presence of a default case,
             // since DCE will eliminate trivial cases like `case _ =>`, even if they're the last one
             // exhaustivity and reachability must be checked before optimization as well
@@ -652,7 +650,7 @@ trait MatchTreeMaking extends MatchCodeGen with Debugging {
 
             val matchRes = codegen.matcher(scrut, scrutSym, pt)(cases map combineExtractors, synthCatchAll)
 
-            if (toHoist isEmpty) matchRes else Block(toHoist, matchRes)
+            if (toHoist.isEmpty) matchRes else Block(toHoist, matchRes)
           } else {
             codegen.matcher(scrut, scrutSym, pt)(Nil, matchFailGen)
           }

src/compiler/scala/tools/nsc/transform/patmat/PatternMatching.scala

@@ -15,7 +15,6 @@ package scala.tools.nsc.transform.patmat
 import scala.collection.mutable.ListBuffer
 import scala.tools.nsc.Global
 import scala.tools.nsc.ast
-import scala.language.postfixOps
 import scala.tools.nsc.transform.TypingTransformers
 import scala.tools.nsc.transform.Transform
 import scala.reflect.internal.util.Statistics
@@ -207,7 +206,7 @@ trait Interface extends ast.TreeDSL {
       def apply(from: Symbol, to: Tree): Substitution = new Substitution(from :: Nil, to :: Nil)
       // requires sameLength(from, to)
       def apply(from: List[Symbol], to: List[Tree]): Substitution =
-        if (from nonEmpty) new Substitution(from, to) else EmptySubstitution
+        if (from.isEmpty) EmptySubstitution else new Substitution(from, to)
     }
 
     class Substitution(val from: List[Symbol], val to: List[Tree]) {

src/compiler/scala/tools/nsc/typechecker/Checkable.scala

@@ -14,7 +14,6 @@ package scala.tools.nsc
 package typechecker
 
 import Checkability._
-import scala.language.postfixOps
 
 /** On pattern matcher checkability:
  *
@@ -292,7 +291,7 @@ trait Checkable {
         case TypeRef(_, NothingClass | NullClass | AnyValClass, _) => false
         case RefinedType(_, decls) if !decls.isEmpty               => false
         case RefinedType(parents, _)                               => parents forall isCheckable
-        case p                                                     => new CheckabilityChecker(AnyTpe, p) isCheckable
+        case p                                                     => new CheckabilityChecker(AnyTpe, p).isCheckable
       })
     )