Add nestedExists extension method

Add nestedExists extension method for List[List[T]] exists and
optimize it as well as nestedMap.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -596,9 +596,9 @@ object desugar {
           (ordinalMethLit(ordinal) :: enumLabelLit(className.toString) :: Nil, scaffolding)
         else (Nil, Nil)
       def copyMeths = {
-        val hasRepeatedParam = constrVparamss.exists(_.exists {
+        val hasRepeatedParam = constrVparamss.nestedExists {
           case ValDef(_, tpt, _) => isRepeated(tpt)
-        })
+        }
         if (mods.is(Abstract) || hasRepeatedParam) Nil  // cannot have default arguments for repeated parameters, hence copy method is not issued
         else {
           def copyDefault(vparam: ValDef) =

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -297,7 +297,7 @@ object DesugarEnums {
       case parent => parent.isType && typeHasRef(parent)
     }
 
-    vparamss.exists(_.exists(valDefHasRef)) || parents.exists(parentHasRef)
+    vparamss.nestedExists(valDefHasRef) || parents.exists(parentHasRef)
   }
 
   /** A pair consisting of

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

@@ -195,12 +195,16 @@ object Decorators {
   }
 
   extension [T, U](xss: List[List[T]])
-    def nestedMap(f: T => U): List[List[U]] =
-      xss.map(_.map(f))
+    def nestedMap(f: T => U): List[List[U]] = xss match
+      case xs :: xss1 => xs.map(f) :: xss1.nestedMap(f)
+      case nil => Nil
     def nestedMapConserve(f: T => U): List[List[U]] =
       xss.mapconserve(_.mapconserve(f))
     def nestedZipWithConserve(yss: List[List[U]])(f: (T, U) => T): List[List[T]] =
       xss.zipWithConserve(yss)((xs, ys) => xs.zipWithConserve(ys)(f))
+    def nestedExists(p: T => Boolean): Boolean = xss match
+      case xs :: xss1 => xs.exists(p) || xss1.nestedExists(p)
+      case nil => false
   end extension
 
   extension (text: Text)

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

@@ -899,7 +899,7 @@ object SymDenotations {
       else if is(NoDefaultParams) then false
       else
         val result =
-          rawParamss.exists(_.exists(_.is(HasDefault)))
+          rawParamss.nestedExists(_.is(HasDefault))
           || allOverriddenSymbols.exists(_.hasDefaultParams)
         setFlag(if result then HasDefaultParams else NoDefaultParams)
         result

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3856,7 +3856,7 @@ object Parsers {
         val problem = tree match
           case tree: MemberDef if !(tree.mods.flags & ModifierFlags).isEmpty =>
             i"refinement cannot be ${(tree.mods.flags & ModifierFlags).flagStrings().mkString("`", "`, `", "`")}"
-          case tree: DefDef if tree.vparamss.exists(_.exists(!_.rhs.isEmpty)) =>
+          case tree: DefDef if tree.vparamss.nestedExists(!_.rhs.isEmpty) =>
             i"refinement cannot have default arguments"
           case tree: ValOrDefDef =>
             if tree.rhs.isEmpty then ""

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

@@ -237,7 +237,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
 
   /** Is there a repeated parameter in some parameter list? */
   private def hasRepeatedParams(sym: Symbol)(using Context): Boolean =
-    sym.info.paramInfoss.flatten.exists(_.isRepeatedParam)
+    sym.info.paramInfoss.nestedExists(_.isRepeatedParam)
 
   /** Is this the type of a method that has a repeated parameter type as
    *  its last parameter in the last parameter list?