Implement wrapParameters option

Rules.md

@@ -1514,13 +1514,40 @@ Align wrapped function arguments or collection elements.
 
 Option | Description
 --- | ---
-`--wraparguments` | Wrap function args: "before-first", "after-first", "preserve"
+`--wraparguments` | Wrap all arguments: "before-first", "after-first", "preserve"
+`--wrapparameters` | Wrap func params: "before-first", "after-first", "preserve"
 `--wrapcollections` | Wrap array/dict: "before-first", "after-first", "preserve"
 `--closingparen` | Closing paren position: "balanced" (default) or "same-line"
 
 <details>
 <summary>Examples</summary>
 
+**NOTE:** For backwards compatibility with previous versions, if no value is
+provided for `--wrapparameters`, the value for `--wraparguments` will be used.
+`--wraparguments before-first`
+
+```diff
+- foo(bar: Int,
+-     baz: String)
+
++ foo(
++   bar: Int,
++   baz: String
++ )
+```
+
+```diff
+- class Foo<Bar,
+-           Baz>
+
++ class Foo<
++   Bar,
++   Baz
++ >
+```
+
+`--wrapparameters after-first`
+
 ```diff
 - func foo(bar: Int,
 -          baz: String) {
@@ -1535,7 +1562,7 @@ Option | Description
   }
 ```
 
-Or for `--wrapcollections before-first`:
+`--wrapcollections before-first`:
 
 ```diff
 - let foo = [bar,

Sources/Examples.swift

@@ -928,6 +928,32 @@ private struct Examples {
     """
 
     let wrapArguments = """
+    **NOTE:** For backwards compatibility with previous versions, if no value is
+    provided for `--wrapparameters`, the value for `--wraparguments` will be used.
+    `--wraparguments before-first`
+
+    ```diff
+    - foo(bar: Int,
+    -     baz: String)
+
+    + foo(
+    +   bar: Int,
+    +   baz: String
+    + )
+    ```
+
+    ```diff
+    - class Foo<Bar,
+    -           Baz>
+
+    + class Foo<
+    +   Bar,
+    +   Baz
+    + >
+    ```
+
+    `--wrapparameters after-first`
+
     ```diff
     - func foo(bar: Int,
     -          baz: String) {
@@ -942,7 +968,7 @@ private struct Examples {
       }
     ```
 
-    Or for `--wrapcollections before-first`:
+    `--wrapcollections before-first`:
 
     ```diff
     - let foo = [bar,

Sources/Options.swift

@@ -249,6 +249,7 @@ public struct FormatOptions: CustomStringConvertible {
     public var fileHeader: HeaderStrippingMode
     public var ifdefIndent: IndentMode
     public var wrapArguments: WrapMode
+    public var wrapParameters: WrapMode
     public var wrapCollections: WrapMode
     public var closingParenOnSameLine: Bool
     public var uppercaseHex: Bool
@@ -300,6 +301,7 @@ public struct FormatOptions: CustomStringConvertible {
                 fileHeader: HeaderStrippingMode = .ignore,
                 ifdefIndent: IndentMode = .indent,
                 wrapArguments: WrapMode = .preserve,
+                wrapParameters: WrapMode = .preserve,
                 wrapCollections: WrapMode = .preserve,
                 closingParenOnSameLine: Bool = false,
                 uppercaseHex: Bool = true,
@@ -343,6 +345,7 @@ public struct FormatOptions: CustomStringConvertible {
         self.fileHeader = fileHeader
         self.ifdefIndent = ifdefIndent
         self.wrapArguments = wrapArguments
+        self.wrapParameters = wrapParameters
         self.wrapCollections = wrapCollections
         self.closingParenOnSameLine = closingParenOnSameLine
         self.uppercaseHex = uppercaseHex

Sources/OptionsDescriptor.swift

@@ -231,6 +231,7 @@ extension FormatOptions.Descriptor {
         fileHeader,
         ifdefIndent,
         wrapArguments,
+        wrapParameters,
         wrapCollections,
         closingParen,
         hexLiteralCase,
@@ -390,10 +391,18 @@ extension FormatOptions.Descriptor {
         argumentName: "wraparguments",
         propertyName: "wrapArguments",
         displayName: "Wrap Arguments",
-        help: "Wrap function args: \"before-first\", \"after-first\", \"preserve\"",
+        help: "Wrap all arguments: \"before-first\", \"after-first\", \"preserve\"",
         keyPath: \.wrapArguments,
         options: ["before-first", "after-first", "preserve", "disabled"]
     )
+    static let wrapParameters = FormatOptions.Descriptor(
+        argumentName: "wrapparameters",
+        propertyName: "wrapParameters",
+        displayName: "Wrap Parameters",
+        help: "Wrap func params: \"before-first\", \"after-first\", \"preserve\"",
+        keyPath: \.wrapParameters,
+        options: ["before-first", "after-first", "preserve", "disabled"]
+    )
     static let wrapCollections = FormatOptions.Descriptor(
         argumentName: "wrapcollections",
         propertyName: "wrapCollections",

Sources/ParsingHelpers.swift

@@ -867,7 +867,7 @@ extension Formatter {
             }
         }
         for scopeType in ["(", "[", "<"] {
-            forEach(.startOfScope(scopeType)) { i, _ in
+            forEach(.startOfScope(scopeType)) { i, _ in // TODO: use token closure arg
                 guard let endOfScope = endOfScope(at: i) else {
                     return
                 }
@@ -888,9 +888,25 @@ extension Formatter {
                         // Not an argument list, or only one argument
                         return
                     }
+
+                    func isParameterList() -> Bool {
+                        if last(.keyword, before: i) == .keyword("func") {
+                            // Is parameters at start of function
+                            return true
+                        }
+
+                        if last(.nonSpaceOrCommentOrLinebreak, before: i) == .delimiter(":"),
+                            next(.nonSpaceOrCommentOrLinebreak, after: endOfScope) == .operator("->", .infix) {
+                            // Is parameter list for a closure type
+                            return true
+                        }
+
+                        return false
+                    }
+
                     checkNestedScopes = false
                     endOfScopeOnSameLine = options.closingParenOnSameLine
-                    fallthrough
+                    mode = isParameterList() ? options.wrapParameters : options.wrapArguments
                 case "<":
                     mode = options.wrapArguments
                 case "[":

Sources/Rules.swift

@@ -3067,7 +3067,7 @@ public struct _FormatRules {
     public let wrap = FormatRule(
         help: "Wrap lines that exceed the specified maximum width.",
         options: ["maxwidth"],
-        sharedOptions: ["wraparguments", "wrapcollections", "closingparen", "indent",
+        sharedOptions: ["wraparguments", "wrapparameters", "wrapcollections", "closingparen", "indent",
                         "trimwhitespace", "linebreaks", "tabwidth", "maxwidth"]
     ) { formatter in
         let maxWidth = formatter.options.maxWidth
@@ -3188,7 +3188,7 @@ public struct _FormatRules {
     /// Normalize argument wrapping style
     public let wrapArguments = FormatRule(
         help: "Align wrapped function arguments or collection elements.",
-        options: ["wraparguments", "wrapcollections", "closingparen"],
+        options: ["wraparguments", "wrapparameters", "wrapcollections", "closingparen"],
         sharedOptions: ["indent", "trimwhitespace", "linebreaks", "tabwidth", "maxwidth"]
     ) { formatter in
         formatter.wrapCollectionsAndArguments(completePartialWrapping: true)

Tests/MetadataTests.swift

@@ -134,7 +134,7 @@ class MetadataTests: XCTestCase {
                     referencedOptions.append(.lineBreak)
                 case .identifier("wrapCollectionsAndArguments"):
                     referencedOptions += [
-                        .wrapArguments, .wrapCollections, .closingParen,
+                        .wrapArguments, .wrapParameters, .wrapCollections, .closingParen,
                         .indentation, .truncateBlankLines, .lineBreak, .tabWidth, .maxWidth,
                     ]
                 case .identifier("options") where formatter.token(at: index + 1) == .operator(".", .infix):