Filters out parameters within parameters

For a function that takes a closure as default value, the array of
parameter reported by sourcekit also includes the parameters of that
closure.

In other words, a function like

func foo(param1: Int,
         param2: Bool,
         param3: (Int) -> Void = { (x: Int) in }) { }

reports 4 parameters (param 1, param2, param3, and x).

This commit uses the bounds of the method/function parameters to filter
out parameters within parameters. Below, a 1, a 2, and a 3 would be
filtered out since they're inside parameter 3.

----------------------------------------------------------------|
|        |---------| |---------| |----------------------------| |
|        | param 1 | | param 2 | | param 3: |a 1| |a 2| |a 3| | |
|        |---------| |---------| |----------------------------| |
----------------------------------------------------------------|

Rules.md

@@ -7062,6 +7062,22 @@ class Foo {
 }
 ```
 
+```swift
+class Foo {
+   class func foo(param1: Int,
+                  param2: Bool,
+                  param3: @escaping (Int) -> Void = { (x: Int) in }) { }
+}
+```
+
+```swift
+class Foo {
+   class func foo(param1: Int,
+                  param2: Bool,
+                  param3: @escaping (Int, (Int) -> Void) -> Void = { (x: Int, f: (Int) -> Void) in }) { }
+}
+```
+
 </details>
 <details>
 <summary>Triggering Examples</summary>
@@ -7199,6 +7215,20 @@ class Foo {
 }
 ```
 
+```swift
+class Foo {
+   class func ↓foo(param1: Int,
+                  param2: Bool, param3: @escaping (Int, Int) -> Void = { _, _ in }) { }
+}
+```
+
+```swift
+class Foo {
+   class func ↓foo(param1: Int,
+                  param2: Bool, param3: @escaping (Int) -> Void = { (x: Int) in }) { }
+}
+```
+
 </details>
 
 

Source/SwiftLintFramework/Rules/MultilineParametersRule.swift

@@ -12,6 +12,8 @@ import SourceKittenFramework
 public struct MultilineParametersRule: ASTRule, OptInRule, ConfigurationProviderRule {
     public var configuration = SeverityConfiguration(.warning)
 
+    private typealias ParameterRange = (offset: Int, length: Int)
+
     public init() {}
 
     public static let description = RuleDescription(
@@ -34,16 +36,26 @@ public struct MultilineParametersRule: ASTRule, OptInRule, ConfigurationProvider
                 return []
         }
 
+        let parameterRanges = dictionary.substructure.flatMap { subStructure -> ParameterRange? in
+            guard
+                let offset = subStructure.offset,
+                let length = subStructure.length,
+                let kind = subStructure.kind, SwiftDeclarationKind(rawValue: kind) == .varParameter
+                else {
+                    return nil
+            }
+
+            return (offset, length)
+        }
+
         var numberOfParameters = 0
         var linesWithParameters = Set<Int>()
 
-        for structure in dictionary.substructure {
+        for range in parameterRanges {
             guard
-                let structureOffset = structure.offset,
-                structure.typeName != nil,
-                let structureKind = structure.kind, SwiftDeclarationKind(rawValue: structureKind) == .varParameter,
-                let (line, _) = file.contents.bridge().lineAndCharacter(forByteOffset: structureOffset),
-                offset..<(offset + length) ~= structureOffset
+                let (line, _) = file.contents.bridge().lineAndCharacter(forByteOffset: range.offset),
+                offset..<(offset + length) ~= range.offset,
+                isRange(range, withinRanges: parameterRanges)
                 else {
                     continue
             }
@@ -63,4 +75,10 @@ public struct MultilineParametersRule: ASTRule, OptInRule, ConfigurationProvider
                                severity: configuration.severity,
                                location: Location(file: file, byteOffset: offset))]
     }
+
+    // MARK: - Private
+
+    private func isRange(_ range: ParameterRange, withinRanges ranges: [ParameterRange]) -> Bool {
+        return ranges.filter { ($0.offset..<($0.offset + $0.length)).contains(range.offset) && $0 != range }.isEmpty
+    }
 }

Source/SwiftLintFramework/Rules/MultilineParametersRuleExamples.swift

@@ -8,6 +8,8 @@
 
 import Foundation
 
+// swiftlint:disable type_body_length
+
 internal struct MultilineParametersRuleExamples {
     static let nonTriggeringExamples = [
         "func foo() { }",
@@ -122,6 +124,16 @@ internal struct MultilineParametersRuleExamples {
         "   class func foo(param1: Int,\n" +
         "                  param2: @escaping ((Int) -> Void)? = { _ in },\n" +
         "                  param3: @escaping (Int, Int) -> Void = { _, _ in }) { }\n" +
+        "}",
+        "class Foo {\n" +
+        "   class func foo(param1: Int,\n" +
+        "                  param2: Bool,\n" +
+        "                  param3: @escaping (Int) -> Void = { (x: Int) in }) { }\n" +
+        "}",
+        "class Foo {\n" +
+        "   class func foo(param1: Int,\n" +
+        "                  param2: Bool,\n" +
+        "                  param3: @escaping (Int, (Int) -> Void) -> Void = { (x: Int, f: (Int) -> Void) in }) { }\n" +
         "}"
     ]
 
@@ -201,6 +213,14 @@ internal struct MultilineParametersRuleExamples {
         "class Foo {\n" +
         "   class func ↓foo(param1: Int, param2: Bool,\n" +
         "                   param3: [String]) { }\n" +
+        "}",
+        "class Foo {\n" +
+        "   class func ↓foo(param1: Int,\n" +
+        "                  param2: Bool, param3: @escaping (Int, Int) -> Void = { _, _ in }) { }\n" +
+        "}",
+        "class Foo {\n" +
+        "   class func ↓foo(param1: Int,\n" +
+        "                  param2: Bool, param3: @escaping (Int) -> Void = { (x: Int) in }) { }\n" +
         "}"
     ]
 }