Some long overdue conveniences.

Not just conveniences though.  One of the clearest statements made
by profiling is that collections methods of the form of the enclosed
flatCollect are materially faster than the alternatives.

11 files changed, 58 insertions, 24 deletions

diff --git a/src/compiler/scala/reflect/internal/Definitions.scala b/src/compiler/scala/reflect/internal/Definitions.scala
index 2b6607e23e..d89e852124 100644
--- a/src/compiler/scala/reflect/internal/Definitions.scala
+++ b/src/compiler/scala/reflect/internal/Definitions.scala
@@ -103,7 +103,7 @@ trait Definitions extends reflect.api.StandardDefinitions {
       getMemberMethod(valueClassCompanion(className.toTermName).moduleClass, methodName)
 
     private def classesMap[T](f: Name => T) = symbolsMap(ScalaValueClassesNoUnit, f)
-    private def symbolsMap[T](syms: List[Symbol], f: Name => T): Map[Symbol, T] = syms zip (syms map (x => f(x.name))) toMap
+    private def symbolsMap[T](syms: List[Symbol], f: Name => T): Map[Symbol, T] = mapFrom(syms)(x => f(x.name))
     private def symbolsMapFilt[T](syms: List[Symbol], p: Name => Boolean, f: Name => T) = symbolsMap(syms filter (x => p(x.name)), f)
 
     private def boxedName(name: Name) = sn.Boxed(name.toTypeName)
diff --git a/src/compiler/scala/reflect/internal/SymbolTable.scala b/src/compiler/scala/reflect/internal/SymbolTable.scala
index 7d9dd282cf..9158c2a4d4 100644
--- a/src/compiler/scala/reflect/internal/SymbolTable.scala
+++ b/src/compiler/scala/reflect/internal/SymbolTable.scala
@@ -76,6 +76,19 @@ abstract class SymbolTable extends api.Universe
     result
   }
 
+  // For too long have we suffered in order to sort NAMES.
+  // I'm pretty sure there's a reasonable default for that.
+  // Notice challenge created by Ordering's invariance.
+  implicit def lowPriorityNameOrdering[T <: Names#Name]: Ordering[T] =
+    SimpleNameOrdering.asInstanceOf[Ordering[T]]
+
+  private object SimpleNameOrdering extends Ordering[Names#Name] {
+    def compare(n1: Names#Name, n2: Names#Name) = (
+      if (n1 eq n2) 0
+      else n1.toString compareTo n2.toString
+    )
+  }
+
   /** Dump each symbol to stdout after shutdown.
    */
   final val traceSymbolActivity = sys.props contains "scalac.debug.syms"
diff --git a/src/compiler/scala/reflect/internal/Types.scala b/src/compiler/scala/reflect/internal/Types.scala
index 815a5c0710..2fe7dfda17 100644
--- a/src/compiler/scala/reflect/internal/Types.scala
+++ b/src/compiler/scala/reflect/internal/Types.scala
@@ -1509,7 +1509,8 @@ trait Types extends api.Types { self: SymbolTable =>
               case tv: TypeVar => tvs += tv
               case _ =>
             }
-          val varToParamMap: Map[Type, Symbol] = tvs map (tv => tv -> tv.origin.typeSymbol.cloneSymbol) toMap
+          val varToParamMap: Map[Type, Symbol] =
+            mapFrom[TypeVar, Type, Symbol](tvs.toList)(_.origin.typeSymbol.cloneSymbol)
           val paramToVarMap = varToParamMap map (_.swap)
           val varToParam = new TypeMap {
             def apply(tp: Type) = varToParamMap get tp match {
@@ -3473,7 +3474,7 @@ trait Types extends api.Types { self: SymbolTable =>
       case TypeRef(pre, sym, _) if sameLength(sym.typeParams, args) =>
         val eparams  = typeParamsToExistentials(sym)
         val bounds   = args map (TypeBounds upper _)
-        (eparams, bounds).zipped foreach (_ setInfo _)
+        foreach2(eparams, bounds)(_ setInfo _)
 
         newExistentialType(eparams, typeRef(pre, sym, eparams map (_.tpe)))
       case _ =>
@@ -3655,7 +3656,7 @@ trait Types extends api.Types { self: SymbolTable =>
           else owner.newValueParameter(name.toTermName)
         paramStack = newParams :: paramStack
         try {
-          (newParams, ptypes).zipped foreach ((p, t) => p setInfo this(t))
+          foreach2(newParams, ptypes)((p, t) => p setInfo this(t))
           val restpe1 = this(restpe)
           if (isType) PolyType(newParams, restpe1)
           else MethodType(newParams, restpe1)
diff --git a/src/compiler/scala/reflect/internal/util/Collections.scala b/src/compiler/scala/reflect/internal/util/Collections.scala
index 9e4ae1ca00..2e119f8ccc 100644
--- a/src/compiler/scala/reflect/internal/util/Collections.scala
+++ b/src/compiler/scala/reflect/internal/util/Collections.scala
@@ -70,6 +70,27 @@ trait Collections {
     lb.toList
   }
   
+  final def flatCollect[A, B](elems: List[A])(pf: PartialFunction[A, Traversable[B]]): List[B] = {
+    val lb = new ListBuffer[B]
+    for (x <- elems ; if pf isDefinedAt x)
+      lb ++= pf(x)
+
+    lb.toList
+  }
+
+  final def distinctBy[A, B](xs: List[A])(f: A => B): List[A] = {
+    val buf = new ListBuffer[A]
+    val seen = mutable.Set[B]()
+    xs foreach { x =>
+      val y = f(x)
+      if (!seen(y)) {
+        buf += x
+        seen += y
+      }
+    }
+    buf.toList
+  }
+
   @tailrec final def flattensToEmpty(xss: Seq[Seq[_]]): Boolean = {
     xss.isEmpty || xss.head.isEmpty && flattensToEmpty(xss.tail)
   }
@@ -89,6 +110,10 @@ trait Collections {
     xs find p getOrElse orElse
   }
 
+  final def mapFrom[A, A1 >: A, B](xs: List[A])(f: A => B): Map[A1, B] = {
+    Map[A1, B](xs map (x => (x, f(x))): _*)
+  }
+
   final def mapWithIndex[A, B](xs: List[A])(f: (A, Int) => B): List[B] = {
     val lb = new ListBuffer[B]
     var index = 0
diff --git a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
index ff58de5f12..5e5b09405c 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/GenICode.scala
@@ -2225,7 +2225,7 @@ abstract class GenICode extends SubComponent  {
        * jumps to the given basic block.
        */
       def patch(code: Code) {
-        val map = toPatch map (i => (i -> patch(i))) toMap;
+        val map = mapFrom(toPatch)(patch)
         code.blocks foreach (_ subst map)
       }
 
diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
index 3d77344091..a9c2ce0d09 100644
--- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala
@@ -369,7 +369,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   def flatName(id: String)    = optFlatName(id) getOrElse id
   def optFlatName(id: String) = requestForIdent(id) map (_ fullFlatName id)
 
-  def allDefinedNames = definedNameMap.keys.toList sortBy (_.toString)
+  def allDefinedNames = definedNameMap.keys.toList.sorted
   def pathToType(id: String): String = pathToName(newTypeName(id))
   def pathToTerm(id: String): String = pathToName(newTermName(id))
   def pathToName(name: Name): String = {
@@ -1007,9 +1007,8 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     def lookupTypeOf(name: Name) = typeOf.getOrElse(name, typeOf(global.encode(name.toString)))
     def simpleNameOfType(name: TypeName) = (compilerTypeOf get name) map (_.typeSymbol.simpleName)
 
-    private def typeMap[T](f: Type => T): Map[Name, T] = {
-      termNames ++ typeNames map (x => x -> f(cleanMemberDecl(resultSymbol, x))) toMap
-    }
+    private def typeMap[T](f: Type => T) =
+      mapFrom[Name, Name, T](termNames ++ typeNames)(x => f(cleanMemberDecl(resultSymbol, x)))
 
     /** Types of variables defined by this request. */
     lazy val compilerTypeOf = typeMap[Type](x => x) withDefaultValue NoType
@@ -1024,8 +1023,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       typeNames.map(x => x -> compilerTypeOf(x).typeSymbol)
     ).toMap[Name, Symbol] withDefaultValue NoSymbol
 
-    lazy val typesOfDefinedTerms: Map[Name, Type] =
-      termNames map (x => x -> applyToResultMember(x, _.tpe)) toMap
+    lazy val typesOfDefinedTerms = mapFrom[Name, Name, Type](termNames)(x => applyToResultMember(x, _.tpe))
 
     /** load and run the code using reflection */
     def loadAndRun: (String, Boolean) = {
diff --git a/src/compiler/scala/tools/nsc/interpreter/Power.scala b/src/compiler/scala/tools/nsc/interpreter/Power.scala
index 01ace0e984..659caad1e1 100644
--- a/src/compiler/scala/tools/nsc/interpreter/Power.scala
+++ b/src/compiler/scala/tools/nsc/interpreter/Power.scala
@@ -231,7 +231,7 @@ class Power[ReplValsImpl <: ReplVals : TypeTag](val intp: IMain, replVals: ReplV
     def shortClass     = erasure.getName split "[$.]" last
 
     def baseClasses                    = tpe.baseClasses
-    def baseClassDecls                 = baseClasses map (x => (x, x.info.decls.toList.sortBy(_.name.toString))) toMap
+    def baseClassDecls                 = mapFrom(baseClasses)(_.info.decls.toList.sortBy(_.name))
     def ancestors                      = baseClasses drop 1
     def ancestorDeclares(name: String) = ancestors filter (_.info member newTermName(name) ne NoSymbol)
     def baseTypes                      = tpe.baseTypeSeq.toList
@@ -362,7 +362,6 @@ class Power[ReplValsImpl <: ReplVals : TypeTag](val intp: IMain, replVals: ReplV
         else if (s1 isLess s2) -1
         else 1
     }
-    implicit lazy val powerNameOrdering: Ordering[Name]     = Ordering[String] on (_.toString)
     implicit lazy val powerSymbolOrdering: Ordering[Symbol] = Ordering[Name] on (_.name)
     implicit lazy val powerTypeOrdering: Ordering[Type]     = Ordering[Symbol] on (_.typeSymbol)
 
diff --git a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
index ff671088ac..1fb7fac184 100644
--- a/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
+++ b/src/compiler/scala/tools/nsc/transform/SpecializeTypes.scala
@@ -820,7 +820,7 @@ abstract class SpecializeTypes extends InfoTransform with TypingTransformers {
 
   // concise printing of type env
   private def pp(env: TypeEnv): String = {
-    env.toList.sortBy(_._1.name.toString) map {
+    env.toList.sortBy(_._1.name) map {
       case (k, v) =>
         val vsym = v.typeSymbol
         if (k == vsym) "" + k.name
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 1612253dd6..0d7ef71193 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -831,7 +831,7 @@ trait Implicits {
 
       /** Returns all eligible ImplicitInfos and their SearchResults in a map.
        */
-      def findAll() = (eligible map (info => (info, typedImplicit(info, false)))).toMap
+      def findAll() = mapFrom(eligible)(typedImplicit(_, false))
 
       /** Returns the SearchResult of the best match.
        */
diff --git a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
index 4319dd10c7..a6a8d6009f 100644
--- a/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/TreeCheckers.scala
@@ -57,7 +57,7 @@ abstract class TreeCheckers extends Analyzer {
 
     def prev          = maps.init.last._2
     def latest        = maps.last._2
-    def sortedNewSyms = newSyms.toList.distinct sortBy (_.name.toString)
+    def sortedNewSyms = newSyms.toList.distinct sortBy (_.name)
 
     def inPrev(sym: Symbol) = {
       (maps.size >= 2) && (prev contains sym)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index 1414424a0b..a956b9a177 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -3289,14 +3289,12 @@ trait Typers extends Modes with Adaptations with Taggings with PatMatVirtualiser
         case tp => tp
       }
 
-      (hidden map { s =>
-        // Hanging onto lower bound in case anything interesting
-        // happens with it.
-        (s, s.existentialBound match {
-          case TypeBounds(lo, hi) => TypeBounds(lo, hiBound(s))
-          case _                  => hiBound(s)
-        })
-      }).toMap
+      // Hanging onto lower bound in case anything interesting
+      // happens with it.
+      mapFrom(hidden)(s => s.existentialBound match {
+        case TypeBounds(lo, hi) => TypeBounds(lo, hiBound(s))
+        case _                  => hiBound(s)
+      })
     }
 
     /** Given a set `rawSyms` of term- and type-symbols, and a type