feat: implement 'convert to named lambda parameters' code action

metals/src/main/scala/scala/meta/internal/metals/ServerCommands.scala

@@ -661,6 +661,20 @@ object ServerCommands {
          |""".stripMargin,
     )
 
+  final case class ConvertToNamedLambdaParametersRequest(
+      position: TextDocumentPositionParams
+  )
+  val ConvertToNamedLambdaParameters =
+    new ParametrizedCommand[ConvertToNamedLambdaParametersRequest](
+      "convert-to-named-lambda-parameters",
+      "Convert wildcard lambda parameters to named parameters",
+      """|Whenever a user chooses code action to convert to named lambda parameters, this command is later run to 
+         |rewrite the lambda to use named parameters.
+         |""".stripMargin,
+      """|Object with [TextDocumentPositionParams](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#textDocumentPositionParams) of the target lambda
+         |""".stripMargin,
+    )
+
   val GotoLog = new Command(
     "goto-log",
     "Check logs",

metals/src/main/scala/scala/meta/internal/metals/codeactions/CodeActionProvider.scala

@@ -49,6 +49,7 @@ final class CodeActionProvider(
     new ConvertCommentCodeAction(buffers),
     new RemoveInvalidImportQuickFix(trees, buildTargets),
     new SourceRemoveInvalidImports(trees, buildTargets, diagnostics),
+    new ConvertToNamedLambdaParameters(trees, compilers, languageClient),
   )
 
   def actionsForParams(params: l.CodeActionParams): List[CodeAction] = {

metals/src/main/scala/scala/meta/internal/metals/codeactions/ConvertToNamedLambdaParameters.scala

@@ -0,0 +1,101 @@
+package scala.meta.internal.metals.codeactions
+
+import scala.concurrent.ExecutionContext
+import scala.concurrent.Future
+
+import scala.meta.Term
+import scala.meta.internal.metals.Compilers
+import scala.meta.internal.metals.MetalsEnrichments._
+import scala.meta.internal.metals.ServerCommands
+import scala.meta.internal.metals.clients.language.MetalsLanguageClient
+import scala.meta.internal.metals.codeactions.CodeAction
+import scala.meta.internal.metals.codeactions.CodeActionBuilder
+import scala.meta.internal.metals.logging
+import scala.meta.internal.parsing.Trees
+import scala.meta.pc.CancelToken
+import scala.meta.pc.CodeActionId
+
+import org.eclipse.{lsp4j => l}
+
+/**
+ * Code action to convert a wildcard lambda to a lambda with named parameters
+ * e.g.
+ *
+ * List(1, 2).map(<<_>> + 1) => List(1, 2).map(i => i + 1)
+ */
+class ConvertToNamedLambdaParameters(
+    trees: Trees,
+    compilers: Compilers,
+    languageClient: MetalsLanguageClient,
+) extends CodeAction {
+
+  override val kind: String = l.CodeActionKind.RefactorRewrite
+
+  override type CommandData =
+    ServerCommands.ConvertToNamedLambdaParametersRequest
+
+  override def command: Option[ActionCommand] = Some(
+    ServerCommands.ConvertToNamedLambdaParameters
+  )
+
+  override def handleCommand(
+      data: ServerCommands.ConvertToNamedLambdaParametersRequest,
+      token: CancelToken,
+  )(implicit ec: ExecutionContext): Future[Unit] = {
+    val uri = data.position.getTextDocument().getUri()
+    for {
+      edits <- compilers.codeAction(
+        data.position,
+        token,
+        CodeActionId.ConvertToNamedLambdaParameters,
+        None,
+      )
+      _ = logging.logErrorWhen(
+        edits.isEmpty(),
+        s"Could not convert lambda at position ${data.position} to named lambda",
+      )
+      workspaceEdit = new l.WorkspaceEdit(Map(uri -> edits).asJava)
+      _ <- languageClient
+        .applyEdit(new l.ApplyWorkspaceEditParams(workspaceEdit))
+        .asScala
+    } yield ()
+  }
+
+  override def contribute(
+      params: l.CodeActionParams,
+      token: CancelToken,
+  )(implicit ec: ExecutionContext): Future[Seq[l.CodeAction]] = {
+    val path = params.getTextDocument().getUri().toAbsolutePath
+    val range = params.getRange()
+    val maybeLambda =
+      trees.findLastEnclosingAt[Term.AnonymousFunction](path, range.getStart())
+    maybeLambda
+      .map { lambda =>
+        val position = new l.TextDocumentPositionParams(
+          params.getTextDocument(),
+          new l.Position(lambda.pos.startLine, lambda.pos.startColumn),
+        )
+        val command =
+          ServerCommands.ConvertToNamedLambdaParameters.toLsp(
+            ServerCommands.ConvertToNamedLambdaParametersRequest(position)
+          )
+        val codeAction = CodeActionBuilder.build(
+          title = ConvertToNamedLambdaParameters.title,
+          kind = kind,
+          command = Some(command),
+        )
+        Future.successful(Seq(codeAction))
+      }
+      .filter(_ =>
+        compilers
+          .supportedCodeActions(path)
+          .contains(CodeActionId.ConvertToNamedLambdaParameters)
+      )
+      .getOrElse(Future.successful(Nil))
+  }
+
+}
+
+object ConvertToNamedLambdaParameters {
+  def title: String = "Convert to named lambda parameters"
+}

mtags-interfaces/src/main/java/scala/meta/pc/CodeActionId.java

@@ -12,4 +12,5 @@ public class CodeActionId {
   public static final String InlineValue = "InlineValue";
   public static final String InsertInferredType = "InsertInferredType";
   public static final String InsertInferredMethod = "InsertInferredMethod";
+  public static final String ConvertToNamedLambdaParameters = "ConvertToNamedLambdaParameters";
 }

tests/cross/src/main/scala/tests/BaseExtractMethodSuite.scala

@@ -10,7 +10,6 @@ import scala.meta.internal.metals.TextEdits
 import munit.Location
 import munit.TestOptions
 import org.eclipse.{lsp4j => l}
-import tests.BaseCodeActionSuite
 
 class BaseExtractMethodSuite extends BaseCodeActionSuite {
   def checkEdit(

tests/slow/src/test/scala/tests/feature/Scala3CodeActionLspSuite.scala

@@ -2,6 +2,7 @@ package tests.feature
 
 import scala.meta.internal.metals.BuildInfo
 import scala.meta.internal.metals.codeactions.ConvertToNamedArguments
+import scala.meta.internal.metals.codeactions.ConvertToNamedLambdaParameters
 import scala.meta.internal.metals.codeactions.CreateCompanionObjectCodeAction
 import scala.meta.internal.metals.codeactions.ExtractMethodCodeAction
 import scala.meta.internal.metals.codeactions.ExtractRenameMember
@@ -771,6 +772,28 @@ class Scala3CodeActionLspSuite
        |""".stripMargin,
   )
 
+  check(
+    "wildcard lambda".ignore,
+    """|package a
+       |
+       |object A {
+       |  val l = List(1, 2, 3)
+       |  l.map(_ + <<1>>)
+       |}
+       |""".stripMargin,
+    s"""|${ConvertToNamedArguments.title("l.map(...)")}
+        |${ConvertToNamedLambdaParameters.title}
+        |""".stripMargin,
+    """|package a
+       |
+       |object A {
+       |  val l = List(1, 2, 3)
+       |  l.map(i => i + 1)
+       |}
+       |""".stripMargin,
+    selectedActionIndex = 1,
+  )
+
   private def getPath(name: String) = s"a/src/main/scala/a/$name"
 
   def checkExtractedMember(