A couple low impact cleanups/optimizations, no ...

A couple low impact cleanups/optimizations, no review.

3 files changed, 26 insertions, 23 deletions

diff --git a/src/compiler/scala/reflect/internal/Symbols.scala b/src/compiler/scala/reflect/internal/Symbols.scala
index 5f2e060d6d..3167bbc5de 100644
--- a/src/compiler/scala/reflect/internal/Symbols.scala
+++ b/src/compiler/scala/reflect/internal/Symbols.scala
@@ -820,9 +820,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         //   one: sourceCompleter to LazyType, two: LazyType to completed type
         if (cnt == 3) abort("no progress in completing " + this + ":" + tp)
       }
-      val result = rawInfo
-      result
-    } catch {
+      rawInfo
+    }
+    catch {
       case ex: CyclicReference =>
         if (settings.debug.value) println("... trying to complete "+this)
         throw ex
@@ -904,12 +904,15 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         val prev1 = adaptInfos(infos.prev)
         if (prev1 ne infos.prev) prev1
         else {
-          def adaptToNewRun(info: Type): Type =
-            if (isPackageClass) info else adaptToNewRunMap(info)
           val pid = phaseId(infos.validFrom)
+
           validTo = period(currentRunId, pid)
-          phase = phaseWithId(pid)
-          val info1 = adaptToNewRun(infos.info)
+          phase   = phaseWithId(pid)
+
+          val info1 = (
+            if (isPackageClass) infos.info
+            else adaptToNewRunMap(infos.info)
+          )
           if (info1 eq infos.info) {
             infos.validFrom = validTo
             infos
diff --git a/src/compiler/scala/tools/nsc/settings/AbsSettings.scala b/src/compiler/scala/tools/nsc/settings/AbsSettings.scala
index 5efe41770e..9cea935a63 100644
--- a/src/compiler/scala/tools/nsc/settings/AbsSettings.scala
+++ b/src/compiler/scala/tools/nsc/settings/AbsSettings.scala
@@ -6,8 +6,6 @@
 package scala.tools.nsc
 package settings
 
-import io.AbstractFile
-
 /** A Settings abstraction boiled out of the original highly mutable Settings
  *  class with the intention of creating an ImmutableSettings which can be used
  *  interchangeably.   Except of course without the mutants.
@@ -32,7 +30,7 @@ trait AbsSettings extends scala.reflect.internal.settings.AbsSettings {
   def lookupSetting(cmd: String): Option[Setting] = allSettings find (_ respondsTo cmd)
 
   // two AbsSettings objects are equal if their visible settings are equal.
-  override def hashCode() = visibleSettings.hashCode
+  override def hashCode() = visibleSettings.size  // going for cheap
   override def equals(that: Any) = that match {
     case s: AbsSettings => this.userSetSettings == s.userSetSettings
     case _              => false
@@ -134,8 +132,8 @@ trait AbsSettings extends scala.reflect.internal.settings.AbsSettings {
       case x: AbsSettings#AbsSetting  => (name == x.name) && (value == x.value)
       case _                          => false
     }
-    override def hashCode() = (name, value).hashCode
-    override def toString() = "%s = %s".format(name, value)
+    override def hashCode() = name.hashCode + value.hashCode
+    override def toString() = name + " = " + value
   }
 
   trait InternalSetting extends AbsSetting {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index ab6d66e111..dde34284b7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -1381,28 +1381,30 @@ trait Namers { self: Analyzer =>
 
   var lockedCount = 0
 
-  def mkTypeCompleter(t: Tree)(c: Symbol => Unit) = new TypeCompleter {
+  def mkTypeCompleter(t: Tree)(c: Symbol => Unit) = new LockingTypeCompleter {
     val tree = t
-    override def complete(sym: Symbol) = try {
+    def completeImpl(sym: Symbol) = c(sym)
+  }
+
+  trait LockingTypeCompleter extends TypeCompleter {
+    def completeImpl(sym: Symbol): Unit
+
+    override def complete(sym: Symbol) = {
       lockedCount += 1
-      c(sym)
-    } finally {
-      lockedCount -= 1
+      try completeImpl(sym)
+      finally lockedCount -= 1
     }
   }
 
   /** A class representing a lazy type with known type parameters.
    */
-  class PolyTypeCompleter(tparams: List[Tree], restp: TypeCompleter, owner: Tree, ownerSym: Symbol, ctx: Context) extends TypeCompleter {
+  class PolyTypeCompleter(tparams: List[Tree], restp: TypeCompleter, owner: Tree, ownerSym: Symbol, ctx: Context) extends LockingTypeCompleter {
     override val typeParams: List[Symbol]= tparams map (_.symbol) //@M
     override val tree = restp.tree
-    override def complete(sym: Symbol) = try {
-      lockedCount += 1
-      if(ownerSym.isAbstractType) //@M an abstract type's type parameters are entered -- TODO: change to isTypeMember ?
+    def completeImpl(sym: Symbol) = {
+      if (ownerSym.isAbstractType) //@M an abstract type's type parameters are entered -- TODO: change to isTypeMember ?
         newNamer(ctx.makeNewScope(owner, ownerSym)).enterSyms(tparams) //@M
       restp.complete(sym)
-    } finally {
-      lockedCount -= 1
     }
   }