Eliminating warnings in Cleanup.

And un-overabstracting it a bit. When a method takes four parameters
in two parameter lists, one of which is a closure acting on a tuple, and
it turns out there are a total of three call sites and they all pass
identical values for the first three parameters, it may be time to
brush up on your YAGNI.

3 files changed, 67 insertions, 74 deletions

diff --git a/src/compiler/scala/reflect/internal/Flags.scala b/src/compiler/scala/reflect/internal/Flags.scala
index 270491d078..8aae80eed4 100644
--- a/src/compiler/scala/reflect/internal/Flags.scala
+++ b/src/compiler/scala/reflect/internal/Flags.scala
@@ -468,33 +468,34 @@ class Flags extends ModifierFlags {
   protected final val rawFlagPickledOrder: Array[Long] = pickledListOrder.toArray
 
   def flagOfModifier(mod: Modifier): Long = mod match {
-    case Modifier.`protected` => PROTECTED
-    case Modifier.`private` => PRIVATE
-    case Modifier.`override` => OVERRIDE
-    case Modifier.`abstract` => ABSTRACT
-    case Modifier.`final`=> FINAL
-    case Modifier.`sealed`=> SEALED
-    case Modifier.`implicit`=> IMPLICIT
-    case Modifier.`lazy`=> LAZY
-    case Modifier.`case`=> CASE
-    case Modifier.`trait`=> TRAIT
-    case Modifier.deferred => DEFERRED
-    case Modifier.interface => INTERFACE
-    case Modifier.mutable => MUTABLE
-    case Modifier.parameter => PARAM
-    case Modifier.`macro` => MACRO
-    case Modifier.covariant => COVARIANT
-    case Modifier.contravariant => CONTRAVARIANT
-    case Modifier.preSuper => PRESUPER
+    case Modifier.`protected`      => PROTECTED
+    case Modifier.`private`        => PRIVATE
+    case Modifier.`override`       => OVERRIDE
+    case Modifier.`abstract`       => ABSTRACT
+    case Modifier.`final`          => FINAL
+    case Modifier.`sealed`         => SEALED
+    case Modifier.`implicit`       => IMPLICIT
+    case Modifier.`lazy`           => LAZY
+    case Modifier.`case`           => CASE
+    case Modifier.`trait`          => TRAIT
+    case Modifier.deferred         => DEFERRED
+    case Modifier.interface        => INTERFACE
+    case Modifier.mutable          => MUTABLE
+    case Modifier.parameter        => PARAM
+    case Modifier.`macro`          => MACRO
+    case Modifier.covariant        => COVARIANT
+    case Modifier.contravariant    => CONTRAVARIANT
+    case Modifier.preSuper         => PRESUPER
     case Modifier.abstractOverride => ABSOVERRIDE
-    case Modifier.local => LOCAL
-    case Modifier.java => JAVA
-    case Modifier.static => STATIC
-    case Modifier.caseAccessor => CASEACCESSOR
+    case Modifier.local            => LOCAL
+    case Modifier.java             => JAVA
+    case Modifier.static           => STATIC
+    case Modifier.caseAccessor     => CASEACCESSOR
     case Modifier.defaultParameter => DEFAULTPARAM
-    case Modifier.defaultInit => DEFAULTINIT
-    case Modifier.paramAccessor => PARAMACCESSOR
-    case Modifier.bynameParameter => BYNAMEPARAM
+    case Modifier.defaultInit      => DEFAULTINIT
+    case Modifier.paramAccessor    => PARAMACCESSOR
+    case Modifier.bynameParameter  => BYNAMEPARAM
+    case _                         => 0
   }
 
   def flagsOfModifiers(mods: List[Modifier]): Long =
diff --git a/src/compiler/scala/tools/nsc/transform/CleanUp.scala b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
index 8ed44b5a31..b21fa4bc83 100644
--- a/src/compiler/scala/tools/nsc/transform/CleanUp.scala
+++ b/src/compiler/scala/tools/nsc/transform/CleanUp.scala
@@ -165,24 +165,19 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
           varSym
         }
 
-        def addStaticMethodToClass(forName: String, forArgsTypes: List[Type], forResultType: Type)
-                                  (forBody: Pair[Symbol, List[Symbol]] => Tree): Symbol = {
+        def addStaticMethodToClass(forBody: (Symbol, Symbol) => Tree): Symbol = {
+          val methSym = currentClass.newMethod(mkTerm(nme.reflMethodName), ad.pos, STATIC | SYNTHETIC)
+          val params  = methSym.newSyntheticValueParams(List(ClassClass.tpe))
+          methSym setInfoAndEnter MethodType(params, MethodClass.tpe)
 
-          val methSym = currentClass.newMethod(mkTerm(forName), ad.pos, STATIC | SYNTHETIC)
-          val params  = methSym.newSyntheticValueParams(forArgsTypes)
-          methSym setInfoAndEnter MethodType(params, forResultType)
-
-          val methDef = typedPos( DefDef(methSym, forBody(methSym -> params)) )
+          val methDef = typedPos(DefDef(methSym, forBody(methSym, params.head)))
           newStaticMembers append transform(methDef)
-
           methSym
         }
 
         def fromTypesToClassArrayLiteral(paramTypes: List[Type]): Tree =
           ArrayValue(TypeTree(ClassClass.tpe), paramTypes map LIT)
 
-        def theTypeClassArray = arrayType(ClassClass.tpe)
-
         /* ... */
         def reflectiveMethodCache(method: String, paramTypes: List[Type]): Symbol = dispatchType match {
           case NO_CACHE =>
@@ -197,12 +192,11 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               */
 
               val reflParamsCacheSym: Symbol =
-                addStaticVariableToClass(nme.reflParamsCacheName, theTypeClassArray, fromTypesToClassArrayLiteral(paramTypes), true)
+                addStaticVariableToClass(nme.reflParamsCacheName, arrayType(ClassClass.tpe), fromTypesToClassArrayLiteral(paramTypes), true)
 
-              addStaticMethodToClass(nme.reflMethodName, List(ClassClass.tpe), MethodClass.tpe) {
-                case Pair(reflMethodSym, List(forReceiverSym)) =>
-                  (REF(forReceiverSym) DOT Class_getMethod)(LIT(method), safeREF(reflParamsCacheSym))
-              }
+              addStaticMethodToClass((_, forReceiverSym) =>
+                gen.mkMethodCall(REF(forReceiverSym), Class_getMethod, Nil, List(LIT(method), safeREF(reflParamsCacheSym)))
+              )
 
             case MONO_CACHE =>
 
@@ -226,7 +220,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               */
 
               val reflParamsCacheSym: Symbol =
-                addStaticVariableToClass(nme.reflParamsCacheName, theTypeClassArray, fromTypesToClassArrayLiteral(paramTypes), true)
+                addStaticVariableToClass(nme.reflParamsCacheName, arrayType(ClassClass.tpe), fromTypesToClassArrayLiteral(paramTypes), true)
 
               val reflMethodCacheSym: Symbol =
                 addStaticVariableToClass(nme.reflMethodCacheName, MethodClass.tpe, NULL, false)
@@ -237,17 +231,16 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               def isCacheEmpty(receiver: Symbol): Tree =
                 reflClassCacheSym.IS_NULL() OR (reflClassCacheSym.GET() OBJ_NE REF(receiver))
 
-              addStaticMethodToClass(nme.reflMethodName, List(ClassClass.tpe), MethodClass.tpe) {
-                case Pair(reflMethodSym, List(forReceiverSym)) =>
-                  BLOCK(
-                    IF (isCacheEmpty(forReceiverSym)) THEN BLOCK(
-                      safeREF(reflMethodCacheSym) === ((REF(forReceiverSym) DOT Class_getMethod)(LIT(method), safeREF(reflParamsCacheSym))) ,
-                      safeREF(reflClassCacheSym) === gen.mkSoftRef(REF(forReceiverSym)),
-                      UNIT
-                    ) ENDIF,
-                    safeREF(reflMethodCacheSym)
-                  )
-              }
+              addStaticMethodToClass((_, forReceiverSym) =>
+                BLOCK(
+                  IF (isCacheEmpty(forReceiverSym)) THEN BLOCK(
+                    safeREF(reflMethodCacheSym) === ((REF(forReceiverSym) DOT Class_getMethod)(LIT(method), safeREF(reflParamsCacheSym))) ,
+                    safeREF(reflClassCacheSym) === gen.mkSoftRef(REF(forReceiverSym)),
+                    UNIT
+                  ) ENDIF,
+                  safeREF(reflMethodCacheSym)
+                )
+              )
 
             case POLY_CACHE =>
 
@@ -273,7 +266,7 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               */
 
               val reflParamsCacheSym: Symbol =
-                addStaticVariableToClass(nme.reflParamsCacheName, theTypeClassArray, fromTypesToClassArrayLiteral(paramTypes), true)
+                addStaticVariableToClass(nme.reflParamsCacheName, arrayType(ClassClass.tpe), fromTypesToClassArrayLiteral(paramTypes), true)
 
               def mkNewPolyCache = gen.mkSoftRef(NEW(TypeTree(EmptyMethodCacheClass.tpe)))
               val reflPolyCacheSym: Symbol = (
@@ -281,26 +274,25 @@ abstract class CleanUp extends Transform with ast.TreeDSL {
               )
               def getPolyCache = gen.mkCast(fn(safeREF(reflPolyCacheSym), nme.get), MethodCacheClass.tpe)
 
-              addStaticMethodToClass(nme.reflMethodName, List(ClassClass.tpe), MethodClass.tpe)
-                { case Pair(reflMethodSym, List(forReceiverSym)) =>
-                  val methodSym = reflMethodSym.newVariable(mkTerm("method"), ad.pos) setInfo MethodClass.tpe
-
-                  BLOCK(
-                    IF (getPolyCache OBJ_EQ NULL) THEN (safeREF(reflPolyCacheSym) === mkNewPolyCache) ENDIF,
-                    VAL(methodSym) === ((getPolyCache DOT methodCache_find)(REF(forReceiverSym))) ,
-                    IF (REF(methodSym) OBJ_!= NULL) .
-                      THEN (Return(REF(methodSym)))
-                    ELSE {
-                      def methodSymRHS  = ((REF(forReceiverSym) DOT Class_getMethod)(LIT(method), safeREF(reflParamsCacheSym)))
-                      def cacheRHS      = ((getPolyCache DOT methodCache_add)(REF(forReceiverSym), REF(methodSym)))
-                      BLOCK(
-                        REF(methodSym)        === (REF(ensureAccessibleMethod) APPLY (methodSymRHS)),
-                        safeREF(reflPolyCacheSym) === gen.mkSoftRef(cacheRHS),
-                        Return(REF(methodSym))
-                      )
-                    }
-                  )
-                }
+              addStaticMethodToClass((reflMethodSym, forReceiverSym) => {
+                val methodSym = reflMethodSym.newVariable(mkTerm("method"), ad.pos) setInfo MethodClass.tpe
+
+                BLOCK(
+                  IF (getPolyCache OBJ_EQ NULL) THEN (safeREF(reflPolyCacheSym) === mkNewPolyCache) ENDIF,
+                  VAL(methodSym) === ((getPolyCache DOT methodCache_find)(REF(forReceiverSym))) ,
+                  IF (REF(methodSym) OBJ_!= NULL) .
+                    THEN (Return(REF(methodSym)))
+                  ELSE {
+                    def methodSymRHS  = ((REF(forReceiverSym) DOT Class_getMethod)(LIT(method), safeREF(reflParamsCacheSym)))
+                    def cacheRHS      = ((getPolyCache DOT methodCache_add)(REF(forReceiverSym), REF(methodSym)))
+                    BLOCK(
+                      REF(methodSym)        === (REF(ensureAccessibleMethod) APPLY (methodSymRHS)),
+                      safeREF(reflPolyCacheSym) === gen.mkSoftRef(cacheRHS),
+                      Return(REF(methodSym))
+                    )
+                  }
+                )
+              })
         }
 
         /* ### HANDLING METHODS NORMALLY COMPILED TO OPERATORS ### */
diff --git a/src/library/scala/reflect/api/Modifier.scala b/src/library/scala/reflect/api/Modifier.scala
index cbfe91e59b..1b67929e15 100644
--- a/src/library/scala/reflect/api/Modifier.scala
+++ b/src/library/scala/reflect/api/Modifier.scala
@@ -2,7 +2,7 @@ package scala.reflect.api
 
 import collection.{ immutable, mutable }
 
-sealed abstract class Modifier {
+abstract class Modifier private[api] () {
   def name: String
   def isKeyword: Boolean
   def sourceString: String = if (isKeyword) "`" + name + "`" else name