Merge pull request #6209 from retronym/faster/december

Assorted compiler optimizations

src/compiler/scala/tools/nsc/CompilationUnits.scala

@@ -80,7 +80,7 @@ trait CompilationUnits { global: Global =>
     /** Synthetic definitions generated by namer, eliminated by typer.
      */
     object synthetics {
-      private val map = mutable.HashMap[Symbol, Tree]()
+      private val map = mutable.AnyRefMap[Symbol, Tree]()
       def update(sym: Symbol, tree: Tree) {
         debuglog(s"adding synthetic ($sym, $tree) to $self")
         map.update(sym, tree)

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

@@ -1121,10 +1121,10 @@ class Global(var currentSettings: Settings, reporter0: Reporter)
     val compiledFiles   = new mutable.HashSet[String]
 
     /** A map from compiled top-level symbols to their source files */
-    val symSource = new mutable.HashMap[Symbol, AbstractFile]
+    val symSource = new mutable.AnyRefMap[Symbol, AbstractFile]
 
     /** A map from compiled top-level symbols to their picklers */
-    val symData = new mutable.HashMap[Symbol, PickleBuffer]
+    val symData = new mutable.AnyRefMap[Symbol, PickleBuffer]
 
     private var phasec: Int  = 0   // phases completed
     private var unitc: Int   = 0   // units completed this phase

src/compiler/scala/tools/nsc/backend/jvm/analysis/BackendUtils.scala

@@ -328,8 +328,11 @@ abstract class BackendUtils extends PerRunInit {
       bTypesFromClassfile.classBTypeFromParsedClassfile(internalName).info.get.nestedClasses.force
 
     def getClassIfNested(internalName: InternalName): Option[ClassBType] = {
-      val c = bTypesFromClassfile.classBTypeFromParsedClassfile(internalName)
-      if (c.isNestedClass.get) Some(c) else None
+      if (internalName.indexOf('$') < 0) None
+      else {
+        val c = bTypesFromClassfile.classBTypeFromParsedClassfile(internalName)
+        if (c.isNestedClass.get) Some(c) else None
+      }
     }
 
     def raiseError(msg: String, sig: String, e: Option[Throwable]): Unit = {
@@ -771,6 +774,15 @@ object BackendUtils {
       private def skipUntil(isDelimiter: CharBooleanFunction): Unit = {
         while (!isDelimiter(current)) { index += 1 }
       }
+      private def skipUntilDelimiter(delimiter: Char): Unit = {
+        sig.indexOf(delimiter, index) match {
+          case -1 =>
+            raiseError(s"Out of bounds", sig)
+            abort() // Don't continue, even if `notifyInvalidSignature` returns
+          case i =>
+            index = i
+        }
+      }
 
       private def appendUntil(builder: java.lang.StringBuilder, isDelimiter: CharBooleanFunction): Unit = {
         val start = index
@@ -814,7 +826,7 @@ object BackendUtils {
           accept(';')
 
         case 'T' =>
-          skipUntil(_ == ';')
+          skipUntilDelimiter(';')
           skip()
 
         case '[' =>
@@ -825,7 +837,7 @@ object BackendUtils {
       private def typeParameters(): Unit = if (current == '<') {
         skip()
         while (current != '>') {
-          skipUntil(_ == ':'); skip()
+          skipUntilDelimiter(':'); skip()
           val c = current
           // The ClassBound can be missing, but only if there's an InterfaceBound after.
           // This is an assumption that's not in the spec, see https://stackoverflow.com/q/44284928

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

@@ -592,7 +592,7 @@ trait Implicits {
                   var ps = params
                   var as = args
                   if (fast) {
-                    while (ps.nonEmpty && as.nonEmpty) {
+                    while (!(ps.isEmpty || as.isEmpty)) {
                       if (!isPlausiblySubType(as.head, ps.head.tpe))
                         return false
                       ps = ps.tail

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

@@ -833,7 +833,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
      *  and should not be used otherwise. TODO: can it be replaced with a tree attachment?
      */
     protected def adapt(tree: Tree, mode: Mode, pt: Type, original: Tree = EmptyTree): Tree = {
-      def hasUndets           = context.undetparams.nonEmpty
+      def hasUndets           = !context.undetparams.isEmpty
       def hasUndetsInMonoMode = hasUndets && !mode.inPolyMode
 
       def adaptToImplicitMethod(mt: MethodType): Tree = {

src/library/scala/collection/IndexedSeqOptimized.scala

@@ -276,5 +276,15 @@ trait IndexedSeqOptimized[+A, +Repr] extends Any with IndexedSeqLike[A, Repr] {
     case _ =>
       super.endsWith(that)
   }
+
+  override def toList: List[A] = {
+    var i = length - 1
+    var result: List[A] = Nil
+    while (i >= 0) {
+      result ::= apply(i)
+      i -= 1
+    }
+    result
+  }
 }
 

src/reflect/scala/reflect/internal/Definitions.scala

@@ -394,10 +394,10 @@ trait Definitions extends api.StandardDefinitions {
     def isCastSymbol(sym: Symbol)          = sym == Any_asInstanceOf || sym == Object_asInstanceOf
 
     def isJavaVarArgsMethod(m: Symbol)      = m.isMethod && isJavaVarArgs(m.info.params)
-    def isJavaVarArgs(params: Seq[Symbol])  = params.nonEmpty && isJavaRepeatedParamType(params.last.tpe)
-    def isScalaVarArgs(params: Seq[Symbol]) = params.nonEmpty && isScalaRepeatedParamType(params.last.tpe)
-    def isVarArgsList(params: Seq[Symbol])  = params.nonEmpty && isRepeatedParamType(params.last.tpe)
-    def isVarArgTypes(formals: Seq[Type])   = formals.nonEmpty && isRepeatedParamType(formals.last)
+    def isJavaVarArgs(params: Seq[Symbol])  = !params.isEmpty && isJavaRepeatedParamType(params.last.tpe)
+    def isScalaVarArgs(params: Seq[Symbol]) = !params.isEmpty && isScalaRepeatedParamType(params.last.tpe)
+    def isVarArgsList(params: Seq[Symbol])  = !params.isEmpty && isRepeatedParamType(params.last.tpe)
+    def isVarArgTypes(formals: Seq[Type])   = !formals.isEmpty && isRepeatedParamType(formals.last)
 
     def firstParamType(tpe: Type): Type = tpe.paramTypes match {
       case p :: _ => p

src/reflect/scala/reflect/internal/Symbols.scala

@@ -70,7 +70,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
    * The original owner of a symbol is needed in some places in the backend. Ideally, owners should
    * be versioned like the type history.
    */
-  private val originalOwnerMap = perRunCaches.newMap[Symbol, Symbol]()
+  private val originalOwnerMap = perRunCaches.newAnyRefMap[Symbol, Symbol]()
 
   // TODO - don't allow the owner to be changed without checking invariants, at least
   // when under some flag. Define per-phase invariants for owner/owned relationships,

src/reflect/scala/reflect/internal/Types.scala

@@ -409,7 +409,7 @@ trait Types
     /** For a class with nonEmpty parents, the first parent.
      *  Otherwise some specific fixed top type.
      */
-    def firstParent = if (parents.nonEmpty) parents.head else ObjectTpe
+    def firstParent = if (!parents.isEmpty) parents.head else ObjectTpe
 
     /** For a typeref or single-type, the prefix of the normalized type (@see normalize).
      *  NoType for all other types. */
@@ -4054,7 +4054,7 @@ trait Types
   def typeParamsToExistentials(clazz: Symbol): List[Symbol] =
     typeParamsToExistentials(clazz, clazz.typeParams)
 
-  def isRawIfWithoutArgs(sym: Symbol) = sym.isClass && sym.typeParams.nonEmpty && sym.isJavaDefined
+  def isRawIfWithoutArgs(sym: Symbol) = sym.isClass && !sym.typeParams.isEmpty && sym.isJavaDefined
   /** Is type tp a ''raw type''? */
   //  note: it's important to write the two tests in this order,
   //  as only typeParams forces the classfile to be read. See #400