Flatten directly

Author: nicolasstucki

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

@@ -1226,14 +1226,14 @@ trait Applications extends Compatibility {
           }
         val dummyArg = dummyTreeOfType(ownType)
         val unapplyApp = typedExpr(untpd.TypedSplice(Apply(unapplyFn, dummyArg :: Nil)))
-        def unapplyImplicits(unapp: Tree): List[List[Tree]] = {
-          val res = List.newBuilder[List[Tree]]
+        def unapplyImplicits(unapp: Tree): List[Tree] = {
+          val res = List.newBuilder[Tree]
           def loop(unapp: Tree): Unit = unapp match {
-            case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); res += args2
+            case Apply(Apply(unapply, `dummyArg` :: Nil), args2) => assert(args2.nonEmpty); res ++= args2
             case Apply(unapply, `dummyArg` :: Nil) =>
             case Inlined(u, _, _) => loop(u)
             case DynamicUnapply(_) => ctx.error("Structural unapply is not supported", unapplyFn.sourcePos)
-            case Apply(fn, args) => assert(args.nonEmpty); loop(fn); res += args
+            case Apply(fn, args) => assert(args.nonEmpty); loop(fn); res ++= args
             case _ => ().assertingErrorsReported
           }
           loop(unapp)
@@ -1254,7 +1254,7 @@ trait Applications extends Compatibility {
             List.fill(argTypes.length - args.length)(WildcardType)
         }
         val unapplyPatterns = bunchedArgs.lazyZip(argTypes) map (typed(_, _))
-        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(unapplyApp).flatten, unapplyPatterns), ownType)
+        val result = assignType(cpy.UnApply(tree)(unapplyFn, unapplyImplicits(unapplyApp), unapplyPatterns), ownType)
         unapp.println(s"unapply patterns = $unapplyPatterns")
         if ((ownType eq selType) || ownType.isError) result
         else tryWithClassTag(Typed(result, TypeTree(ownType)), selType)