opt: fuse some operations on `Scope`s

`Scope`'s `filter` is implemented using `toList`,
so may as well start with `toList`ourselves.

Also fused some `filter`/`foreach` combos.

4 files changed, 24 insertions, 22 deletions

diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
index 9d02228ab5..f2237a0716 100644
--- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
@@ -192,8 +192,7 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
             extensionDefs(currentOwner.companionModule) = new mutable.ListBuffer[Tree]
             currentOwner.primaryConstructor.makeNotPrivate(NoSymbol)
             // SI-7859 make param accessors accessible so the erasure can generate unbox operations.
-            val paramAccessors = currentOwner.info.decls.filter(sym => sym.isParamAccessor && sym.isMethod)
-            paramAccessors.foreach(_.makeNotPrivate(currentOwner))
+            currentOwner.info.decls.foreach(sym => if (sym.isParamAccessor && sym.isMethod) sym.makeNotPrivate(currentOwner))
             super.transform(tree)
           } else if (currentOwner.isStaticOwner) {
             super.transform(tree)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 8943ec810d..2773ee19cf 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -463,7 +463,7 @@ trait Namers extends MethodSynthesis {
         //      opening up the package object on the classpath at all if one exists in source.
         if (m.isPackageObject) {
           val packageScope = m.enclosingPackageClass.rawInfo.decls
-          packageScope.filter(_.owner != m.enclosingPackageClass).toList.foreach(packageScope unlink _)
+          packageScope.foreach(mem => if (mem.owner != m.enclosingPackageClass) packageScope unlink mem)
         }
         updatePosFlags(m, tree.pos, moduleFlags)
         setPrivateWithin(tree, m)
diff --git a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
index 2d454c2fe6..a5a680d135 100644
--- a/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/RefChecks.scala
@@ -172,12 +172,12 @@ abstract class RefChecks extends InfoTransform with scala.reflect.internal.trans
 
       // This has become noisy with implicit classes.
       if (settings.warnPolyImplicitOverload && settings.developer) {
-        clazz.info.decls filter (x => x.isImplicit && x.typeParams.nonEmpty) foreach { sym =>
+        clazz.info.decls.foreach(sym => if (sym.isImplicit && sym.typeParams.nonEmpty) {
           // implicit classes leave both a module symbol and a method symbol as residue
           val alts = clazz.info.decl(sym.name).alternatives filterNot (_.isModule)
           if (alts.size > 1)
             alts foreach (x => reporter.warning(x.pos, "parameterized overloaded implicit methods are not visible as view bounds"))
-        }
+        })
       }
     }
 
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index dcf14612c9..0b55a732d8 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -2391,19 +2391,20 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
               }
               // The block is an anonymous class definitions/instantiation pair
               //   -> members that are hidden by the type of the block are made private
-              val toHide = (
-                classDecls filter (member =>
-                     member.isTerm
-                  && member.isPossibleInRefinement
-                  && member.isPublic
-                  && !matchesVisibleMember(member)
-                ) map (member => member
-                  resetFlag (PROTECTED | LOCAL)
-                  setFlag (PRIVATE | SYNTHETIC_PRIVATE)
-                  setPrivateWithin NoSymbol
-                )
-              )
-              syntheticPrivates ++= toHide
+              classDecls foreach { toHide =>
+                if (toHide.isTerm
+                    && toHide.isPossibleInRefinement
+                    && toHide.isPublic
+                    && !matchesVisibleMember(toHide)) {
+                  (toHide
+                   resetFlag (PROTECTED | LOCAL)
+                   setFlag (PRIVATE | SYNTHETIC_PRIVATE)
+                   setPrivateWithin NoSymbol)
+
+                  syntheticPrivates += toHide
+                }
+              }
+
             case _ =>
           }
         }
@@ -3641,10 +3642,12 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
             reportAnnotationError(MultipleArgumentListForAnnotationError(ann))
           }
           else {
-            val annScope = annType.decls
-                .filter(sym => sym.isMethod && !sym.isConstructor && sym.isJavaDefined)
+            val annScopeJava =
+              if (isJava) annType.decls.filter(sym => sym.isMethod && !sym.isConstructor && sym.isJavaDefined)
+              else EmptyScope // annScopeJava is only used if isJava
+
             val names = mutable.Set[Symbol]()
-            names ++= (if (isJava) annScope.iterator
+            names ++= (if (isJava) annScopeJava.iterator
                        else typedFun.tpe.params.iterator)
 
             def hasValue = names exists (_.name == nme.value)
@@ -3655,7 +3658,7 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
 
             val nvPairs = args map {
               case arg @ AssignOrNamedArg(Ident(name), rhs) =>
-                val sym = if (isJava) annScope.lookup(name)
+                val sym = if (isJava) annScopeJava.lookup(name)
                           else findSymbol(typedFun.tpe.params)(_.name == name)
                 if (sym == NoSymbol) {
                   reportAnnotationError(UnknownAnnotationNameError(arg, name))