Add convert to trailing closure and editor placeholder refactorings

Adds three new refactorings:
  - `ConvertToTrailingClosures`
  - `ExpandEditorPlaceholder`
  - `ExpandEditorPlaceholders`

`ExpandEditorPlaceholders` is a combination of `ExpandEditorPlaceholder`
and `ConvertToTrailingClosures`, ie. it first expands any function-typed
closures at the end of a call using `ExpandEditorPlaceholder` and then
runs `ConvertToTrailingClosures` on that call.

Resolves rdar://107532856.

Author: bnbarham

Sources/SwiftRefactor/CallToTrailingClosures.swift

@@ -0,0 +1,123 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftBasicFormat
+import SwiftSyntax
+
+/// Convert a call with inline closures to one that uses trailing closure
+/// syntax. Returns `nil` if there's already trailing closures or there are no
+/// closures within the call. Pass `conversionStart` to specify an index to
+/// start the conversion from, ie. to skip converting closures before
+/// `conversionStart`
+///
+/// ## Before
+/// ```
+/// someCall(closure1: (String) -> Int, closure2: (String) -> Int)
+/// ```
+///
+/// ## After
+/// ```
+/// someCall { arg in
+///   <#code#>
+/// } closure2: { arg in
+///   <#code#>
+/// }
+/// ```
+public struct CallToTrailingClosures: SyntaxRefactoringProvider {
+  public struct Options {
+    public let startAt: Int
+
+    public init(startAt: Int = 0) {
+      self.startAt = startAt
+    }
+  }
+  public typealias Context = Options
+
+  // TODO: Rather than returning nil, we should consider throwing errors with
+  // appropriate messages instead.
+  public static func refactor(syntax call: FunctionCallExprSyntax, in context: Context = Context()) -> FunctionCallExprSyntax? {
+    return call.convertToTrailingClosures(from: context.startAt)?.formatted().as(FunctionCallExprSyntax.self)
+  }
+}
+
+extension FunctionCallExprSyntax {
+  fileprivate func convertToTrailingClosures(from startAt: Int) -> FunctionCallExprSyntax? {
+    guard trailingClosure == nil, additionalTrailingClosures == nil, leftParen != nil, rightParen != nil else {
+      // Already have trailing closures
+      return nil
+    }
+
+    var closures = [(label: TokenSyntax, closure: ClosureExprSyntax)]()
+    for arg in argumentList.dropFirst(startAt) {
+      guard var closure = arg.expression.as(ClosureExprSyntax.self) else {
+        closures.removeAll()
+        continue
+      }
+
+      // Trailing comma won't exist any more, move its trivia to the end of
+      // the closure instead
+      if let comma = arg.trailingComma {
+        closure = closure.with(\.trailingTrivia, closure.trailingTrivia.merging(triviaOf: comma))
+      }
+      closures.append((arg.label ?? .wildcardToken(), closure))
+    }
+
+    guard !closures.isEmpty else {
+      return nil
+    }
+
+    let trailingClosure = closures.first!.closure
+    let additionalTrailingClosures = closures.dropFirst().map {
+      MultipleTrailingClosureElementSyntax(
+        label: $0.label,
+        colon: .colonToken(),
+        closure: $0.closure
+      )
+    }
+
+    var converted = self
+
+    var argList = Array(argumentList.dropLast(closures.count))
+    if argList.isEmpty {
+      converted =
+        converted
+        .with(\.leftParen, nil)
+        .with(\.rightParen, nil)
+    } else {
+      // Remove the last comma and move its trivia to after the right paren.
+      // Also move all the trailing comma trivia of each closure. The right
+      // paren's trivia was moved to the very end of the call above.
+      let last = argList.last!
+      if let comma = last.trailingComma {
+        converted =
+          converted
+          .with(\.rightParen, TokenSyntax.rightParenToken(trailingTrivia: Trivia().merging(triviaOf: comma)))
+      }
+      argList[argList.count - 1] =
+        last
+        .with(\.trailingComma, nil)
+    }
+
+    converted =
+      converted
+      .with(\.argumentList, TupleExprElementListSyntax(argList))
+      .with(\.trailingClosure, trailingClosure)
+    if !additionalTrailingClosures.isEmpty {
+      converted = converted.with(\.additionalTrailingClosures, MultipleTrailingClosureElementListSyntax(additionalTrailingClosures))
+    }
+    if let rightParen = rightParen {
+      converted = converted.with(\.trailingTrivia, converted.trailingTrivia.merging(triviaOf: rightParen))
+    }
+
+    return converted
+  }
+}