Apply CR suggestion to use different functions

for methods/lambdas argument format

Author: fmonniot

compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala

@@ -158,7 +158,7 @@ object SourceCode {
           for paramClause <- paramss do
             paramClause match
               case TermParamClause(params) =>
-                printArgsDefs(params)
+                printMethdArgsDefs(params)
               case TypeParamClause(params) =>
                 printTargsDefs(stats.collect { case targ: TypeDef => targ  }.filter(_.symbol.isTypeParam).zip(params))
         }
@@ -313,7 +313,7 @@ object SourceCode {
         this += highlightKeyword("def ") += highlightValDef(name1)
         for clause <-  paramss do
           clause match
-            case TermParamClause(params) => printArgsDefs(params)
+            case TermParamClause(params) => printMethdArgsDefs(params)
             case TypeParamClause(params) => printTargsDefs(params.zip(params))
         if (!isConstructor) {
           this += ": "
@@ -460,7 +460,7 @@ object SourceCode {
 
       case tree @ Lambda(params, body) =>  // must come before `Block`
         inParens {
-          printArgsDefs(params, isLambda = true)
+          printLambdaArgsDefs(params)
           this += (if tree.tpe.isContextFunctionType then " ?=> " else  " => ")
           printTree(body)
         }
@@ -804,14 +804,35 @@ object SourceCode {
       }
     }
 
-    private def printArgsDefs(args: List[ValDef], isLambda: Boolean = false)(using elideThis: Option[Symbol]): Unit = {
+    private def printMethdArgsDefs(args: List[ValDef])(using elideThis: Option[Symbol]): Unit = {
+      val argFlags = args match {
+        case Nil => Flags.EmptyFlags
+        case arg :: _ => arg.symbol.flags
+      }
+      inParens {
+        if (argFlags.is(Flags.Implicit) && !argFlags.is(Flags.Given)) this += "implicit "
+        if (argFlags.is(Flags.Given)) this += "using "
+
+        def printSeparated(list: List[ValDef]): Unit = list match {
+          case Nil =>
+          case x :: Nil => printParamDef(x)
+          case x :: xs =>
+            printParamDef(x)
+            this += ", "
+            printSeparated(xs)
+        }
+
+        printSeparated(args)
+      }
+    }
+
+    private def printLambdaArgsDefs(args: List[ValDef])(using elideThis: Option[Symbol]): Unit = {
       val argFlags = args match {
         case Nil => Flags.EmptyFlags
         case arg :: _ => arg.symbol.flags
       }
       inParens {
         if (argFlags.is(Flags.Implicit) && !argFlags.is(Flags.Given)) this += "implicit "
-        if (argFlags.is(Flags.Given) && !isLambda) this += "using "
 
         def printSeparated(list: List[ValDef]): Unit = list match {
           case Nil =>