Merge pull request #5205 from adriaanm/misc-opt

Small optimizations around use of Scopes.

6 files changed, 56 insertions, 51 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..72da4498c7 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -2068,35 +2068,39 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
         case _ =>
           (call, Nil)
       }
-      val (superConstr, superArgs) = decompose(rhs)
-      assert(superConstr.symbol ne null, superConstr)//debug
-      def superClazz = superConstr.symbol.owner
-      def superParamAccessors = superClazz.constrParamAccessors
 
       // associate superclass paramaccessors with their aliases
-      if (superConstr.symbol.isPrimaryConstructor && !superClazz.isJavaDefined && sameLength(superParamAccessors, superArgs)) {
-        for ((superAcc, superArg @ Ident(name)) <- superParamAccessors zip superArgs) {
-          if (mexists(vparamss)(_.symbol == superArg.symbol)) {
-            val alias = (
-              superAcc.initialize.alias
-                orElse (superAcc getterIn superAcc.owner)
-                filter (alias => superClazz.info.nonPrivateMember(alias.name) == alias)
-            )
-            if (alias.exists && !alias.accessed.isVariable && !isRepeatedParamType(alias.accessed.info)) {
-              val ownAcc = clazz.info decl name suchThat (_.isParamAccessor) match {
-                case acc if !acc.isDeferred && acc.hasAccessorFlag => acc.accessed
-                case acc                                           => acc
-              }
-              ownAcc match {
-                case acc: TermSymbol if !acc.isVariable && !isByNameParamType(acc.info) =>
-                  debuglog(s"$acc has alias ${alias.fullLocationString}")
-                  acc setAlias alias
-                case _ =>
+      val (superConstr, superArgs) = decompose(rhs)
+      if (superConstr.symbol.isPrimaryConstructor) {
+        val superClazz = superConstr.symbol.owner
+        if (!superClazz.isJavaDefined) {
+          val superParamAccessors = superClazz.constrParamAccessors
+          if (sameLength(superParamAccessors, superArgs)) {
+            for ((superAcc, superArg@Ident(name)) <- superParamAccessors zip superArgs) {
+              if (mexists(vparamss)(_.symbol == superArg.symbol)) {
+                val alias = (
+                  superAcc.initialize.alias
+                  orElse (superAcc getterIn superAcc.owner)
+                  filter (alias => superClazz.info.nonPrivateMember(alias.name) == alias)
+                  )
+                if (alias.exists && !alias.accessed.isVariable && !isRepeatedParamType(alias.accessed.info)) {
+                  val ownAcc = clazz.info decl name suchThat (_.isParamAccessor) match {
+                    case acc if !acc.isDeferred && acc.hasAccessorFlag => acc.accessed
+                    case acc => acc
+                  }
+                  ownAcc match {
+                    case acc: TermSymbol if !acc.isVariable && !isByNameParamType(acc.info) =>
+                      debuglog(s"$acc has alias ${alias.fullLocationString}")
+                      acc setAlias alias
+                    case _ =>
+                  }
+                }
               }
             }
           }
         }
       }
+
       pending.foreach(ErrorUtils.issueTypeError)
     }
 
@@ -2391,19 +2395,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 +3646,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 +3662,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))
diff --git a/src/reflect/scala/reflect/internal/Definitions.scala b/src/reflect/scala/reflect/internal/Definitions.scala
index ca6c893d13..fe6d88e7c7 100644
--- a/src/reflect/scala/reflect/internal/Definitions.scala
+++ b/src/reflect/scala/reflect/internal/Definitions.scala
@@ -863,12 +863,13 @@ trait Definitions extends api.StandardDefinitions {
         //    Scopes()
         // must filter out "universal" members (getClass is deferred for some reason)
         val deferredMembers = (
-          tp membersBasedOnFlags (excludedFlags = BridgeAndPrivateFlags, requiredFlags = METHOD)
-          filter (mem => mem.isDeferredNotJavaDefault && !isUniversalMember(mem)) // TODO: test
+          tp.membersBasedOnFlags(excludedFlags = BridgeAndPrivateFlags, requiredFlags = METHOD).toList.filter(
+            mem => mem.isDeferredNotJavaDefault && !isUniversalMember(mem)
+          ) // TODO: test
         )
 
         // if there is only one, it's monomorphic and has a single argument list
-        if (deferredMembers.size == 1 &&
+        if (deferredMembers.lengthCompare(1) == 0 &&
             deferredMembers.head.typeParams.isEmpty &&
             deferredMembers.head.info.paramSectionCount == 1)
           deferredMembers.head
diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 49202cd71e..97b7f239f0 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -2036,11 +2036,9 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
         }
       }
     }
-    private final def caseFieldAccessorsUnsorted: List[Symbol] =
-      (info.decls filter (_.isCaseAccessorMethod)).toList
+    private final def caseFieldAccessorsUnsorted: List[Symbol] = info.decls.toList.filter(_.isCaseAccessorMethod)
 
-    final def constrParamAccessors: List[Symbol] =
-      info.decls.filter(sym => !sym.isMethod && sym.isParamAccessor).toList
+    final def constrParamAccessors: List[Symbol] = info.decls.toList.filter(sym => !sym.isMethod && sym.isParamAccessor)
 
     /** The symbol accessed by this accessor (getter or setter) function. */
     final def accessed: Symbol = {