Small cleanups

3 files changed, 42 insertions, 39 deletions

diff --git a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
index ed76e66aa0..aa53a22ade 100644
--- a/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
+++ b/src/compiler/scala/tools/nsc/backend/icode/Opcodes.scala
@@ -16,6 +16,7 @@ import scala.tools.nsc.util.{Position,NoPosition}
   A pattern match
 
   case THIS(clasz) =>
+  case STORE_THIS(kind) =>
   case CONSTANT(const) =>
   case LOAD_ARRAY_ITEM(kind) =>
   case LOAD_LOCAL(local) =>
@@ -40,6 +41,8 @@ import scala.tools.nsc.util.{Position,NoPosition}
   case DUP(kind) =>
   case MONITOR_ENTER() =>
   case MONITOR_EXIT() =>
+  case BOX(boxType) =>
+  case UNBOX(tpe) =>
   case SCOPE_ENTER(lv) =>
   case SCOPE_EXIT(lv) =>
   case LOAD_EXCEPTION() =>
diff --git a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
index 69bcae5312..70bea2d44a 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/ClosureElimination.scala
@@ -24,7 +24,37 @@ abstract class ClosureElimination extends SubComponent {
   /** Create a new phase */
   override def newPhase(p: Phase) = new ClosureEliminationPhase(p)
 
-  /** The Inlining phase.
+  /** A simple peephole optimizer. */
+  val peephole = new PeepholeOpt( (i1, i2) =>
+    (i1, i2) match {
+      case (CONSTANT(c), DROP(_)) =>
+        if (c.tag == UnitTag)
+          Some(List(i2))
+        else
+          Some(Nil);
+
+      case (LOAD_LOCAL(x), STORE_LOCAL(y)) =>
+        if (x eq y) Some(Nil) else None
+
+      case (STORE_LOCAL(x), LOAD_LOCAL(y)) if (x == y) =>
+        Some(List(DUP(x.kind), STORE_LOCAL(x)))
+
+      case (LOAD_LOCAL(_), DROP(_)) | (DUP(_), DROP(_)) =>
+        Some(Nil)
+
+      case (BOX(t1), UNBOX(t2)) if (t1 == t2) =>
+        Some(Nil)
+
+      case (LOAD_FIELD(sym, isStatic), DROP(_)) if !sym.hasAnnotation(definitions.VolatileAttr) =>
+        if (isStatic)
+          Some(Nil)
+        else
+          Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil);
+
+      case _ => None
+    });
+
+  /** The closure elimination phase.
    */
   class ClosureEliminationPhase(prev: Phase) extends ICodePhase(prev) {
 
@@ -52,36 +82,6 @@ abstract class ClosureElimination extends SubComponent {
       ret
     }
 
-    /** A simple peephole optimizer. */
-    val peephole = new PeepholeOpt( (i1, i2) =>
-    	(i1, i2) match {
-        case (CONSTANT(c), DROP(_)) =>
-          if (c.tag == UnitTag)
-            Some(List(i2))
-          else
-            Some(Nil);
-
-        case (LOAD_LOCAL(x), STORE_LOCAL(y)) =>
-        	if (x eq y) Some(Nil) else None
-
-//        case (STORE_LOCAL(x), LOAD_LOCAL(y)) if (x == y) =>
-//          Some(List(DUP(x.kind), STORE_LOCAL(x)))
-
-        case (LOAD_LOCAL(_), DROP(_)) | (DUP(_), DROP(_)) =>
-          Some(Nil)
-
-        case (BOX(t1), UNBOX(t2)) if (t1 == t2) =>
-          Some(Nil)
-
-        case (LOAD_FIELD(sym, isStatic), DROP(_)) =>
-        	if (isStatic)
-            Some(Nil)
-          else
-            Some(DROP(REFERENCE(definitions.ObjectClass)) :: Nil);
-
-        case _ => None
-      });
-
     def analyzeClass(cls: IClass): Unit = if (settings.Xcloselim.value) {
       cls.methods.foreach { m =>
         analyzeMethod(m)
diff --git a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
index a2b24fe0cb..4fb8067840 100644
--- a/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
+++ b/src/compiler/scala/tools/nsc/backend/opt/Inliners.scala
@@ -223,9 +223,9 @@ abstract class Inliners extends SubComponent {
       while (retry && count < MAX_INLINE_RETRY)
 
       m.normalize
-		}
+    }
 
-		private def isMonadicMethod(sym: Symbol) = sym.name match {
+    private def isMonadicMethod(sym: Symbol) = sym.name match {
       case nme.foreach | nme.filter | nme.map | nme.flatMap => true
       case _                                                => false
     }
@@ -234,17 +234,17 @@ abstract class Inliners extends SubComponent {
 
     /** Should method 'sym' being called in 'receiver' be loaded from disk? */
     def shouldLoadImplFor(sym: Symbol, receiver: Symbol): Boolean = {
-      if (settings.debug.value)
-        log("shouldLoadImplFor: " + receiver + "." + sym)
-
       def alwaysLoad    = (receiver.enclosingPackage == RuntimePackage) || (receiver == PredefModule.moduleClass)
       def loadCondition = sym.isEffectivelyFinal && isMonadicMethod(sym) && isHigherOrderMethod(sym)
 
-      hasInline(sym) || alwaysLoad || loadCondition
+      val res = hasInline(sym) || alwaysLoad || loadCondition
+      if (settings.debug.value)
+        log("shouldLoadImplFor: " + receiver + "." + sym + ": " + res)
+      res
     }
 
-		/** Look up implementation of method 'sym in 'clazz'.
-		 */
+    /** Look up implementation of method 'sym in 'clazz'.
+     */
     def lookupImplFor(sym: Symbol, clazz: Symbol): Symbol = {
       // TODO: verify that clazz.superClass is equivalent here to clazz.tpe.parents(0).typeSymbol (.tpe vs .info)
       def needsLookup = (clazz != NoSymbol) && (clazz != sym.owner) && !sym.isEffectivelyFinal && clazz.isFinal