Minor style cleanups, no changes in logic

4 files changed, 11 insertions, 35 deletions

diff --git a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
index 6d5b697925..f1ccc29afc 100644
--- a/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
+++ b/src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala
@@ -266,7 +266,7 @@ abstract class ClassfileParser {
      *  arrays are considered to be class types, they might
      *  appear as entries in 'newarray' or 'cast' opcodes.
      */
-    def getClassOrArrayType(index: Int): Type = (
+    def getClassOrArrayType(index: Int): Type = {
       if (index <= 0 || len <= index) errorBadIndex(index)
       else values(index) match {
         case tp: Type    => tp
@@ -278,7 +278,7 @@ abstract class ClassfileParser {
             case _         => recordAtIndex(classNameToSymbol(name), index).tpe_*
           }
       }
-    )
+    }
 
     def getType(index: Int): Type              = getType(null, index)
     def getType(sym: Symbol, index: Int): Type = sigToType(sym, getExternalName(index))
@@ -1140,10 +1140,10 @@ abstract class ClassfileParser {
     private def innerSymbol(entry: InnerClassEntry): Symbol = {
       val name      = entry.originalName.toTypeName
       val enclosing = entry.enclosing
-      val member = (
+      val member = {
         if (enclosing == clazz) entry.scope lookup name
         else lookupMemberAtTyperPhaseIfPossible(enclosing, name)
-      )
+      }
       def newStub = enclosing.newStubSymbol(name, s"Unable to locate class corresponding to inner class entry for $name in owner ${entry.outerName}")
       member.orElse(newStub)
     }
diff --git a/src/reflect/scala/reflect/internal/Mirrors.scala b/src/reflect/scala/reflect/internal/Mirrors.scala
index ff2bed8105..6b1063ccd9 100644
--- a/src/reflect/scala/reflect/internal/Mirrors.scala
+++ b/src/reflect/scala/reflect/internal/Mirrors.scala
@@ -211,27 +211,6 @@ trait Mirrors extends api.Mirrors {
       try body
       catch { case _: MissingRequirementError => NoSymbol }
 
-    /** getModule2/getClass2 aren't needed at present but may be again,
-     *  so for now they're mothballed.
-     */
-    // def getModule2(name1: Name, name2: Name) = {
-    //   try getModuleOrClass(name1.toTermName)
-    //   catch { case ex1: FatalError =>
-    //     try getModuleOrClass(name2.toTermName)
-    //     catch { case ex2: FatalError => throw ex1 }
-    //   }
-    // }
-    // def getClass2(name1: Name, name2: Name) = {
-    //   try {
-    //     val result = getModuleOrClass(name1.toTypeName)
-    //     if (result.isAliasType) getClass(name2) else result
-    //   }
-    //   catch { case ex1: FatalError =>
-    //     try getModuleOrClass(name2.toTypeName)
-    //     catch { case ex2: FatalError => throw ex1 }
-    //   }
-    // }
-
     def init() {
       if (initialized) return
       // Still fiddling with whether it's cleaner to do some of this setup here
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 80ccce8e83..8d77e334db 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -302,9 +302,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def newClassConstructor(pos: Position): MethodSymbol =
       newConstructor(pos) setInfo MethodType(Nil, this.tpe)
 
-    def newLinkedModule(clazz: Symbol, newFlags: Long = 0L): ModuleSymbol = {
-      val m = newModuleSymbol(clazz.name.toTermName, clazz.pos, MODULE | newFlags)
-      connectModuleToClass(m, clazz.asInstanceOf[ClassSymbol])
+    def newLinkedModule(moduleClass: Symbol, newFlags: Long = 0L): ModuleSymbol = {
+      val m = newModuleSymbol(moduleClass.name.toTermName, moduleClass.pos, MODULE | newFlags)
+      connectModuleToClass(m, moduleClass.asInstanceOf[ClassSymbol])
     }
     final def newModule(name: TermName, pos: Position = NoPosition, newFlags0: Long = 0L): ModuleSymbol = {
       val newFlags = newFlags0 | MODULE
@@ -1063,7 +1063,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
           // parent LowPriorityImplicits. See comment in c5441dc for more elaboration.
           // Since the fix for SI-7335 Predef parents must be defined in Predef.scala, and we should not
           // get here anymore.
-          devWarning(s"calling Symbol#exists with sourcefile based symbol loader may give incorrect results.");
+          devWarning(s"calling Symbol#exists with sourcefile based symbol loader may give incorrect results.")
       }
 
       rawInfo load this
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index c335bf0f47..016351c639 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -38,10 +38,6 @@ abstract class UnPickler {
       assert(classRoot != NoSymbol && moduleRoot != NoSymbol, s"The Unpickler expects a class and module symbol: $classRoot - $moduleRoot")
       new Scan(bytes, offset, classRoot, moduleRoot, filename).run()
     } catch {
-      case ex: IOException =>
-        throw ex
-      case ex: MissingRequirementError =>
-        throw ex
       case ex: Throwable =>
         /*if (settings.debug.value)*/ ex.printStackTrace()
         throw new RuntimeException("error reading Scala signature of "+filename+": "+ex.getMessage())
@@ -355,9 +351,10 @@ abstract class UnPickler {
           sym
 
         case MODULEsym =>
-          val clazz = at(inforef, () => readType()).typeSymbol // after NMT_TRANSITION, we can leave off the () => ... ()
+          val moduleClass = at(inforef, () => readType()).typeSymbol // after NMT_TRANSITION, we can leave off the () => ... ()
           if (isModuleRoot) moduleRoot setFlag pflags
-          else owner.newLinkedModule(clazz, pflags)
+          else owner.newLinkedModule(moduleClass, pflags)
+
         case VALsym =>
           if (isModuleRoot) { abort(s"VALsym at module root: owner = $owner, name = $name") }
           else owner.newTermSymbol(name.toTermName, NoPosition, pflags)