Avoid some map and flatMap calls

Author: odersky

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

@@ -829,7 +829,7 @@ object Types {
      */
     final def possibleSamMethods(using Context): Seq[SingleDenotation] = {
       record("possibleSamMethods")
-      abstractTermMembers.filterConserve(m =>
+      abstractTermMembers.toList.filterConserve(m =>
         !m.symbol.matchingMember(defn.ObjectType).exists && !m.symbol.isSuperAccessor)
     }
 
@@ -3180,7 +3180,12 @@ object Types {
     private var myParamRefs: List[ParamRefType] = null
 
     def paramRefs: List[ParamRefType] = {
-      if (myParamRefs == null) myParamRefs = paramNames.indices.toList.map(newParamRef)
+      if myParamRefs == null then
+        def recur(paramNames: List[ThisName], i: Int): List[ParamRefType] =
+          paramNames match
+            case _ :: rest => newParamRef(i) :: recur(rest, i + 1)
+            case _ => Nil
+        myParamRefs = recur(paramNames, 0)
       myParamRefs
     }
 

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

@@ -22,6 +22,7 @@ import reporting._
 import config.Printers.{exhaustivity => debug}
 import util.SrcPos
 import NullOpsDecorator._
+import collection.mutable
 
 /** Space logic for checking exhaustivity and unreachability of pattern matching
  *
@@ -123,10 +124,13 @@ trait SpaceLogic {
       else if (canDecompose(tp) && decompose(tp).isEmpty) Empty
       else sp
     case Or(spaces) =>
-      val set = spaces.map(simplify(_)).flatMap {
-        case Or(ss) => ss
-        case s => Seq(s)
-      }.filterConserve(_ != Empty)
+      val buf = new mutable.ListBuffer[Space]
+      def include(s: Space) = if s != Empty then buf += s
+      for space <- spaces do
+        simplify(space) match
+          case Or(ss) => ss.foreach(include)
+          case s => include(s)
+      val set = buf.toList
 
       if (set.isEmpty) Empty
       else if (set.size == 1) set.toList(0)