Merge pull request scala#7109 from retronym/topic/misc-aug

A pocketful of micro optimizations

Author: dwijnand

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

@@ -825,8 +825,9 @@ abstract class Erasure extends InfoTransform
         case Ident(_) | Select(_, _) =>
           if (tree1.symbol.isOverloaded) {
             val first = tree1.symbol.alternatives.head
+            val firstTpe = first.tpe
             val sym1 = tree1.symbol.filter {
-              alt => alt == first || !(first.tpe looselyMatches alt.tpe)
+              alt => alt == first || !(firstTpe looselyMatches alt.tpe)
             }
             if (tree.symbol ne sym1) {
               tree1 setSymbol sym1 setType sym1.tpe

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

@@ -902,14 +902,19 @@ trait Definitions extends api.StandardDefinitions {
           }
         }
       }
+      def isVolatileTypeRef(tr: TypeRef) = {
+        val dealised = tr.dealias
+        if (dealised ne tr) isVolatile(dealised)
+        else if (tr.sym.isAbstractType) isVolatileAbstractType
+        else false
+      }
 
       tp match {
         case ThisType(_)                              => false
         case SingleType(_, sym)                       => isVolatile(tp.underlying) && (sym.hasVolatileType || !sym.isStable)
         case NullaryMethodType(restpe)                => isVolatile(restpe)
         case PolyType(_, restpe)                      => isVolatile(restpe)
-        case TypeRef(_, _, _) if tp ne tp.dealias     => isVolatile(tp.dealias)
-        case TypeRef(_, sym, _) if sym.isAbstractType => isVolatileAbstractType
+        case tr: TypeRef                              => isVolatileTypeRef(tr)
         case RefinedType(_, _)                        => isVolatileRefinedType
         case TypeVar(origin, _)                       => isVolatile(origin)
         case _: SimpleTypeProxy                       => isVolatile(tp.underlying)

src/reflect/scala/reflect/internal/Names.scala

@@ -191,7 +191,7 @@ trait Names extends api.Names {
     // compile loses track of this fact.
 
     /** Index into name table */
-    def start: Int = index
+    final def start: Int = index
 
     /** The next name in the same hash bucket. */
     def next: Name with ThisNameType

src/reflect/scala/reflect/internal/Scopes.scala

@@ -312,12 +312,12 @@ trait Scopes extends api.Scopes { self: SymbolTable =>
       var e: ScopeEntry = null
       if (hashtable ne null) {
         e = hashtable(name.start & HASHMASK)
-        while ((e ne null) && e.sym.name != name) {
+        while ((e ne null) && (e.sym.name ne name)) {
           e = e.tail
         }
       } else {
         e = elems
-        while ((e ne null) && e.sym.name != name) {
+        while ((e ne null) && (e.sym.name ne name)) {
           e = e.next
         }
       }

src/reflect/scala/reflect/internal/SymbolTable.scala

@@ -229,8 +229,6 @@ abstract class SymbolTable extends macros.Universe
   }
 
   final def phase_=(p: Phase): Unit = {
-    //System.out.println("setting phase to " + p)
-    assert((p ne null) && p != NoPhase, p)
     ph = p
     per = period(currentRunId, p.id)
   }

src/reflect/scala/reflect/internal/tpe/TypeMaps.scala

@@ -130,8 +130,8 @@ private[internal] trait TypeMaps {
       */
     protected def noChangeToSymbols(origSyms: List[Symbol]): Boolean = {
       @tailrec def loop(syms: List[Symbol]): Boolean = syms match {
-        case Nil     => true
         case x :: xs => (x.info eq applyToSymbolInfo(x)) && loop(xs)
+        case _       => true
       }
       loop(origSyms)
     }