Reduce allocations in Uncurry.transformArgs

  - Use map2conserve to reuse the incoming argument list in the
    common case when there are no vararg or by-name translations
    to make
  - Avoid the temporary list of types in `.paramTypes` in favour of
    just getting the list of `params` (`Symbols`) and reading the
    `.info` of them

Author: retronym

src/compiler/scala/tools/nsc/transform/UnCurry.scala

@@ -247,8 +247,9 @@ abstract class UnCurry extends InfoTransform
         }
       }
 
-    def transformArgs(pos: Position, fun: Symbol, args: List[Tree], formals: List[Type]): List[Tree] = {
+    def transformArgs(pos: Position, fun: Symbol, args: List[Tree], params: List[Symbol]): List[Tree] = {
       val isJava = fun.isJavaDefined
+
       def transformVarargs(varargsElemType: Type) = {
         def mkArrayValue(ts: List[Tree], elemtp: Type) =
           ArrayValue(TypeTree(elemtp), ts) setType arrayType(elemtp)
@@ -314,7 +315,7 @@ abstract class UnCurry extends InfoTransform
               else arrayToSequence(tree, varargsElemType, copy = isNewCollections) // existing array, make a defensive copy
           }
           else {
-            def mkArray = mkArrayValue(args drop (formals.length - 1), varargsElemType)
+            def mkArray = mkArrayValue(args drop (params.length - 1), varargsElemType)
             if (javaStyleVarArgs) mkArray
             else if (args.isEmpty) gen.mkNil  // avoid needlessly double-wrapping an empty argument list
             else arrayToSequence(mkArray, varargsElemType, copy = false) // fresh array, no need to copy
@@ -328,18 +329,19 @@ abstract class UnCurry extends InfoTransform
             }
           }
         }
-        args.take(formals.length - 1) :+ (suffix setType formals.last)
+        args.take(params.length - 1) :+ (suffix setType params.last.info)
       }
 
-      val args1 = if (isVarArgTypes(formals)) transformVarargs(formals.last.typeArgs.head.widen) else args
+      val isVarargs = isVarArgsList(params)
+      val args1 = if (isVarargs) transformVarargs(params.last.info.typeArgs.head.widen) else args
 
-      map2(formals, args1) { (formal, arg) =>
-        if (!isByNameParamType(formal)) arg
+      map2Conserve(args1, params) { (arg, param) =>
+        if (!isByNameParamType(param.info)) arg
         else if (isByNameRef(arg)) { // thunk does not need to be forced because it's a reference to a by-name arg passed to a by-name param
           byNameArgs += arg
           arg setType functionType(Nil, arg.tpe)
         } else {
-          log(s"Argument '$arg' at line ${arg.pos.line} is $formal from ${fun.fullName}")
+          log(s"Argument '$arg' at line ${arg.pos.line} is ${param.info} from ${fun.fullName}")
           def canUseDirectly(qual: Tree) = qual.tpe.typeSymbol.isSubClass(FunctionClass(0)) && treeInfo.isExprSafeToInline(qual)
           arg match {
             // don't add a thunk for by-name argument if argument already is an application of
@@ -482,16 +484,16 @@ abstract class UnCurry extends InfoTransform
               super.transform(tree)
 
           case Apply(fn, args) =>
-            // Read formals before `transform(fn)`, because UnCurry replaces T* by Seq[T] (see DesugaredParameterType).
+            // Read the param symbols before `transform(fn)`, because UnCurry replaces T* by Seq[T] (see DesugaredParameterType).
             // The call to `transformArgs` below needs `formals` that still have varargs.
-            val formals = fn.tpe.paramTypes
+            val fnParams = fn.tpe.params
             val transformedFn = transform(fn)
             // scala/bug#6479: no need to lift in args to label jumps
             // scala/bug#11127: boolean && / || are emitted using jumps, the lhs stack value is consumed by the conditional jump
             val noReceiverOnStack = fn.symbol.isLabel || fn.symbol == currentRun.runDefinitions.Boolean_and || fn.symbol == currentRun.runDefinitions.Boolean_or
             val needLift = needTryLift || !noReceiverOnStack
             withNeedLift(needLift) {
-              treeCopy.Apply(tree, transformedFn, transformTrees(transformArgs(tree.pos, fn.symbol, args, formals)))
+              treeCopy.Apply(tree, transformedFn, transformTrees(transformArgs(tree.pos, fn.symbol, args, fnParams)))
             }
 
           case Assign(_: RefTree, _) =>