Use same logic to match over all lists

Author: nicolasstucki

library/src-3.x/scala/internal/quoted/Matcher.scala

@@ -39,16 +39,17 @@ object Matcher {
 
     inline def withEnv[T](env: Env)(body: => given Env => T): T = body given env
 
-    /** Check that all trees match with =#= and concatenate the results with && */
-    def (scrutinees: List[Tree]) =##= (patterns: List[Tree]) given Env: Matching = {
-      def rec(l1: List[Tree], l2: List[Tree]): Matching = (l1, l2) match {
-        case (x :: xs, y :: ys) => x =#= y && rec(xs, ys)
-        case (Nil, Nil) => matched
-        case _ => notMatched
-      }
-      rec(scrutinees, patterns)
+    /** Check that all trees match with `mtch` and concatenate the results with && */
+    def matchLists[T](l1: List[T], l2: List[T])(mtch: (T, T) => Matching): Matching = (l1, l2) match {
+      case (x :: xs, y :: ys) => mtch(x, y) && matchLists(xs, ys)(mtch)
+      case (Nil, Nil) => matched
+      case _ => notMatched
     }
 
+    /** Check that all trees match with =#= and concatenate the results with && */
+    def (scrutinees: List[Tree]) =##= (patterns: List[Tree]) given Env: Matching =
+      matchLists(scrutinees, patterns)(_ =#= _)
+
     /** Check that the trees match and return the contents from the pattern holes.
      *  Return None if the trees do not match otherwise return Some of a tuple containing all the contents in the holes.
      *
@@ -178,9 +179,7 @@ object Matcher {
 
         case (DefDef(_, typeParams1, paramss1, tpt1, Some(rhs1)), DefDef(_, typeParams2, paramss2, tpt2, Some(rhs2))) =>
           val typeParmasMatch = typeParams1 =##= typeParams2
-          val paramssMatch =
-            if (paramss1.size != paramss2.size) notMatched
-            else foldMatchings(paramss1.zip(paramss2).map { (params1, params2) => params1 =##= params2 }: _*)
+          val paramssMatch = matchLists(paramss1, paramss2)(_ =##= _)
           val bindMatch =
             if (hasBindAnnotation(pattern.symbol)) bindingMatch(scrutinee.symbol)
             else matched
@@ -199,16 +198,12 @@ object Matcher {
 
         case (Match(scru1, cases1), Match(scru2, cases2)) =>
           val scrutineeMacth = scru1 =#= scru2
-          val casesMatch =
-            if (cases1.size != cases2.size) notMatched
-            else foldMatchings(cases1.zip(cases2).map(caseMatches): _*)
+          val casesMatch = matchLists(cases1, cases2)(caseMatches)
           scrutineeMacth && casesMatch
 
         case (Try(body1, cases1, finalizer1), Try(body2, cases2, finalizer2)) =>
           val bodyMacth = body1 =#= body2
-          val casesMatch =
-            if (cases1.size != cases2.size) notMatched
-              else foldMatchings(cases1.zip(cases2).map(caseMatches): _*)
+          val casesMatch = matchLists(cases1, cases2)(caseMatches)
           val finalizerMatch = treeOptMatches(finalizer1, finalizer2)
           bodyMacth && casesMatch && finalizerMatch
 
@@ -282,9 +277,7 @@ object Matcher {
 
       case (Pattern.Unapply(fun1, implicits1, patterns1), Pattern.Unapply(fun2, implicits2, patterns2)) =>
         val funMatch = fun1 =#= fun2
-        val implicitsMatch =
-          if (implicits1.size != implicits2.size) notMatched
-          else foldMatchings(implicits1.zip(implicits2).map((i1, i2) => i1 =#= i2): _*)
+        val implicitsMatch = implicits1 =##= implicits2
         val (patEnv, patternsMatch) = foldPatterns(patterns1, patterns2)
         (patEnv, funMatch && implicitsMatch && patternsMatch)