Turn some filter operations into filterConserve

replace filter by filterConserve if

 - the call is warm (called for more than 10% of source lines)
 - the filter predicate has a high chance of succeeding

Avoid filter altogether if there's a faster alternative

Author: odersky

compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala

@@ -409,7 +409,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         if isRemovable(param.binder) then remove(param.binder)
         else updateEntry(this, param, replacement)
 
-      def removeParam(ps: List[TypeParamRef]) = ps.filter(param ne _)
+      def removeParam(ps: List[TypeParamRef]) = ps.filterConserve(param ne _)
 
       def replaceParam(tp: Type, atPoly: TypeLambda, atIdx: Int): Type =
         current.ensureNonCyclic(atPoly.paramRefs(atIdx), tp.substParam(param, replacement))

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -829,8 +829,8 @@ object Types {
      */
     final def possibleSamMethods(using Context): Seq[SingleDenotation] = {
       record("possibleSamMethods")
-      abstractTermMembers
-        .filterNot(m => m.symbol.matchingMember(defn.ObjectType).exists || m.symbol.isSuperAccessor)
+      abstractTermMembers.filterConserve(m =>
+        !m.symbol.matchingMember(defn.ObjectType).exists && !m.symbol.isSuperAccessor)
     }
 
     /** The set of abstract type members of this type. */

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -977,7 +977,7 @@ object Erasure {
         if (takesBridges(ctx.owner)) new Bridges(ctx.owner.asClass, erasurePhase).add(stats0)
         else stats0
       val (stats2, finalCtx) = super.typedStats(stats1, exprOwner)
-      (stats2.filter(!_.isEmpty), finalCtx)
+      (stats2.filterConserve(!_.isEmpty), finalCtx)
     }
 
     override def adapt(tree: Tree, pt: Type, locked: TypeVars, tryGadtHealing: Boolean)(using Context): Tree =

compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala

@@ -33,7 +33,7 @@ object OverridingPairs {
      *  pair has already been treated in a parent class.
      *  This may be refined in subclasses. @see Bridges for a use case.
      */
-    protected def parents: Array[Symbol] = base.info.parents.toArray map (_.typeSymbol)
+    protected def parents: Array[Symbol] = base.info.parents.toArray.map(_.typeSymbol)
 
     /** Does `sym1` match `sym2` so that it qualifies as overriding.
      *  Types always match. Term symbols match if their membertypes
@@ -64,11 +64,12 @@ object OverridingPairs {
       decls
     }
 
-    private val subParents =
-      val subParents = MutableSymbolMap[BitSet]()
-      for (bc <- base.info.baseClasses)
-        subParents(bc) = BitSet(parents.indices.filter(parents(_).derivesFrom(bc)): _*)
-      subParents
+    private val subParents = MutableSymbolMap[BitSet]()
+    for bc <- base.info.baseClasses do
+      var bits = BitSet.empty
+      for i <- 0 until parents.length do
+        if parents(i).derivesFrom(bc) then bits += i
+      subParents(bc) = bits
 
     private def hasCommonParentAsSubclass(cls1: Symbol, cls2: Symbol): Boolean =
       (subParents(cls1) intersect subParents(cls2)).nonEmpty

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -126,7 +126,7 @@ trait SpaceLogic {
       val set = spaces.map(simplify(_)).flatMap {
         case Or(ss) => ss
         case s => Seq(s)
-      } filter (_ != Empty)
+      }.filterConserve(_ != Empty)
 
       if (set.isEmpty) Empty
       else if (set.size == 1) set.toList(0)

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1832,7 +1832,7 @@ trait Applications extends Compatibility {
         }
 
         def narrowBySize(alts: List[TermRef]): List[TermRef] =
-          alts.filter(sizeFits(_))
+          alts.filterConserve(sizeFits(_))
 
         def narrowByShapes(alts: List[TermRef]): List[TermRef] =
           val normArgs = args.mapWithIndexConserve(normArg(alts, _, _))
@@ -1843,11 +1843,11 @@ trait Applications extends Compatibility {
             alts
 
         def narrowByTrees(alts: List[TermRef], args: List[Tree], resultType: Type): List[TermRef] = {
-          val alts2 = alts.filter(alt =>
+          val alts2 = alts.filterConserve(alt =>
             isDirectlyApplicableMethodRef(alt, args, resultType)
           )
           if (alts2.isEmpty && !ctx.isAfterTyper)
-            alts.filter(alt =>
+            alts.filterConserve(alt =>
               isApplicableMethodRef(alt, args, resultType, keepConstraint = false)
             )
           else

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -1205,7 +1205,7 @@ trait Implicits:
                   case retained: SearchSuccess =>
                     val newPending =
                       if (retained eq found) || remaining.isEmpty then remaining
-                      else remaining.filter(cand =>
+                      else remaining.filterConserve(cand =>
                         compareCandidate(retained, cand.ref, cand.level) <= 0)
                     rank(newPending, retained, rfailures)
                   case fail: SearchFailure =>

compiler/src/dotty/tools/dotc/typer/Nullables.scala

@@ -399,14 +399,20 @@ object Nullables:
         tree match
           case Block(stats, expr) =>
             var shadowed: Set[(Name, List[Span])] = Set.empty
-            for case (stat: ValDef) <- stats if stat.mods.is(Mutable) do
-              for prevSpans <- candidates.put(stat.name, Nil) do
-                shadowed += (stat.name -> prevSpans)
-              reachable += stat.name
+            for stat <- stats do
+              stat match
+                case stat: ValDef if stat.mods.is(Mutable) =>
+                  for prevSpans <- candidates.put(stat.name, Nil) do
+                    shadowed += (stat.name -> prevSpans)
+                  reachable += stat.name
+                case _ =>
             traverseChildren(tree)
-            for case (stat: ValDef) <- stats if stat.mods.is(Mutable) do
-              for spans <- candidates.remove(stat.name) do
-                tracked += (stat.nameSpan.start -> spans) // candidates that survive until here are tracked
+            for stat <- stats do
+              stat match
+                case stat: ValDef if stat.mods.is(Mutable) =>
+                  for spans <- candidates.remove(stat.name) do
+                    tracked += (stat.nameSpan.start -> spans) // candidates that survive until here are tracked
+                case _ =>
             candidates ++= shadowed
           case Assign(Ident(name), rhs) =>
             candidates.get(name) match

compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -40,7 +40,7 @@ trait TypeAssigner {
   }
 
   def avoidingType(expr: Tree, bindings: List[Tree])(using Context): Type =
-    TypeOps.avoid(expr.tpe, localSyms(bindings).filter(_.isTerm))
+    TypeOps.avoid(expr.tpe, localSyms(bindings).filterConserve(_.isTerm))
 
   def avoidPrivateLeaks(sym: Symbol)(using Context): Type =
     if sym.owner.isClass && !sym.isOneOf(JavaOrPrivateOrSynthetic)