Add new prefer_key_path rule

CHANGELOG.md

@@ -61,6 +61,11 @@
   [SimplyDanny](https://github.com/SimplyDanny)
   [#70](https://github.com/realm/SwiftLint/issues/70)
 
+* Add new `prefer_key_path` rule that triggers when a trailing closure on a function 
+  call is only hosting a (chained) member access expression since the closure can be
+  replaced with a key path argument.  
+  [SimplyDanny](https://github.com/SimplyDanny)
+
 * Warn when `--fix` comes together with `--strict` or `--lenient` as only `--fix`
   takes effect then.  
   [SimplyDanny](https://github.com/SimplyDanny)

Source/SwiftLintBuiltInRules/Models/BuiltInRules.swift

@@ -146,6 +146,7 @@ public let builtInRules: [any Rule.Type] = [
     OverrideInExtensionRule.self,
     PatternMatchingKeywordsRule.self,
     PeriodSpacingRule.self,
+    PreferKeyPathRule.self,
     PreferNimbleRule.self,
     PreferSelfInStaticReferencesRule.self,
     PreferSelfTypeOverTypeOfSelfRule.self,

Source/SwiftLintBuiltInRules/Rules/Idiomatic/PreferKeyPathRule.swift

@@ -0,0 +1,68 @@
+import SwiftLintCore
+import SwiftSyntax
+
+@SwiftSyntaxRule
+struct PreferKeyPathRule: OptInRule {
+    var configuration = SeverityConfiguration<Self>(.warning)
+
+    static var description = RuleDescription(
+        identifier: "prefer_key_path",
+        name: "Prefer Key Path",
+        description: "Use a key path argument instead of a closure with property access",
+        kind: .idiomatic,
+        minSwiftVersion: .fiveDotTwo,
+        nonTriggeringExamples: [
+            Example("f {}"),
+            Example("f { $0 }"),
+            Example("f() { g() }"),
+            Example("f { a.b.c }"),
+            Example("f { a in a }"),
+            Example("f { a, b in a.b }"),
+            Example("f { (a, b) in a.b }")
+        ],
+        triggeringExamples: [
+            Example("f ↓{ $0.a }"),
+            Example("f ↓{ a in a.b }"),
+            Example("f ↓{ a in a.b.c }"),
+            Example("f ↓{ (a: A) in a.b }"),
+            Example("f ↓{ (a b: A) in b.c }")
+        ]
+    )
+}
+
+private extension PreferKeyPathRule {
+    final class Visitor: ViolationsSyntaxVisitor<ConfigurationType> {
+        override func visitPost(_ node: FunctionCallExprSyntax) {
+            if let closure = node.trailingClosure,
+               case let .expr(expr) = closure.statements.onlyElement?.item,
+               expr.accesses(identifier: closure.onlyParameter) {
+                violations.append(closure.positionAfterSkippingLeadingTrivia)
+            }
+        }
+    }
+}
+
+private extension ExprSyntax {
+    func accesses(identifier: String?) -> Bool {
+        if let access = `as`(MemberAccessExprSyntax.self) {
+            if let declRef = access.base?.as(DeclReferenceExprSyntax.self) {
+                return declRef.baseName.text == identifier ?? "$0"
+            }
+            return false
+        }
+        return false
+    }
+}
+
+private extension ClosureExprSyntax {
+    var onlyParameter: String? {
+        switch signature?.parameterClause {
+        case let .simpleInput(params):
+            return params.onlyElement?.name.text
+        case let .parameterClause(params):
+            let param = params.parameters.onlyElement
+            return param?.secondName?.text ?? param?.firstName.text
+        case nil: return nil
+        }
+    }
+}

Tests/GeneratedTests/GeneratedTests.swift

@@ -865,6 +865,12 @@ final class PeriodSpacingRuleGeneratedTests: SwiftLintTestCase {
     }
 }
 
+final class PreferKeyPathRuleGeneratedTests: SwiftLintTestCase {
+    func testWithDefaultConfiguration() {
+        verifyRule(PreferKeyPathRule.description)
+    }
+}
+
 final class PreferNimbleRuleGeneratedTests: SwiftLintTestCase {
     func testWithDefaultConfiguration() {
         verifyRule(PreferNimbleRule.description)