Add 'Reduce Into Instead Of Loop' rule

CHANGELOG.md

@@ -36,6 +36,10 @@
 
 * Add new `allowed_numbers` option to the `no_magic_numbers` rule.  
   [Martin Redington](https://github.com/mildm8nnered)
+* Add new `reduce_into_instead_of_loop` opt-in rule that triggers when a  
+  `for ... in <sequence>` is used to update a sequence where a `reduce(into:)` is  
+  preferred.  
+  [Alfons Hoogervorst](https://github.com/snofla/SwiftLint)
 
 ### Bug Fixes
 

Source/SwiftLintBuiltInRules/Models/BuiltInRules.swift

@@ -169,6 +169,7 @@ public let builtInRules: [any Rule.Type] = [
     QuickDiscouragedPendingTestRule.self,
     RawValueForCamelCasedCodableEnumRule.self,
     ReduceBooleanRule.self,
+    ReduceIntoInsteadOfLoopRule.self,
     ReduceIntoRule.self,
     RedundantDiscardableLetRule.self,
     RedundantNilCoalescingRule.self,

Source/SwiftLintBuiltInRules/Rules/Idiomatic/ReduceIntoInsteadOfLoopRuleExamples.swift

@@ -0,0 +1,119 @@
+struct ReduceIntoInsteadOfLoopRuleExamples {
+    static let nonTriggeringExamples: [Example] = [
+        Example("""
+            let result: [SomeType] = someSequence.reduce(into: [], { result, eachN in
+                result.insert(eachN)
+            })
+        """),
+        Example("""
+            let result: Set<SomeType> = someSequence.reduce(into: []], { result, eachN in
+                result.insert(eachN)
+            })
+        """),
+        Example("""
+            let result: [SomeType1: SomeType2] = someSequence.reduce(into: [:], { result, eachN in
+                result[SomeType1Value] = SomeType2Value
+            })
+        """),
+    ]
+
+    static let triggeringExamples: [Example] =
+          triggeringArrayExamples
+        + triggeringSetExamples
+        + triggeringDictionaryExamples
+}
+
+extension ReduceIntoInsteadOfLoopRuleExamples {
+    private static let triggeringDictionaryExamples: [Example] = [
+        Example("""
+            var result: Dictionary<SomeType1, SomeType2> = [:]
+            for eachN in someSequence {
+                ↓result[SomeType1Value] = SomeType2Value + eachN
+            }
+        """),
+        Example("""
+            var result: Dictionary<SomeType1, SomeType2> = [:]
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+        Example("""
+            var result: Dictionary<SomeType1, SomeType2> = .init()
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+        Example("""
+            var result = Dictionary<SomeType1, SomeType2>()
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+    ]
+
+    private static let triggeringSetExamples: [Example] = [
+        Example("""
+            var result: Set<SomeType> = []
+            for eachN in someSequence {
+                ↓result = result + [eachN]
+            }
+        """),
+        Example("""
+            var result: Set<SomeType> = []
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+        Example("""
+            var result: Set<SomeType> = .init()
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+        Example("""
+            var result = Set<SomeType>()
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+    ]
+
+    private static let triggeringArrayExamples: [Example] = [
+        Example("""
+            var result: [SomeType] = []
+            for eachN in someSequence {
+                ↓result[5] = eachN
+            }
+        """),
+        Example("""
+            var result: [SomeType] = []
+            for eachN in someSequence {
+                ↓result = result + [eachN]
+            }
+        """),
+        Example("""
+            var result: [SomeType] = []
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+        Example("""
+            var result: [SomeType] = .init()
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+        Example("""
+            var result = Array<SomeType>()
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+        Example("""
+            var result = [SomeType]()
+            for eachN in someSequence {
+                ↓result.someMethod(eachN)
+            }
+        """),
+    ]
+}

Source/SwiftLintBuiltInRules/Rules/Idiomatic/ReduceIntoInsteadOfLoopRuleHelpers.swift

@@ -0,0 +1,27 @@
+import SwiftSyntax
+
+struct ReduceIntoInsteadOfLoopRuleHelpers { }
+
+extension VariableDeclSyntax {
+    /// Binding is a var: "`var` someVar = <...>"
+    var isVar: Bool {
+        self.bindingSpecifier.tokenKind == .keyword(.var)
+    }
+
+    var identifier: String? {
+        guard let identifierPattern = self.firstPatternOf(IdentifierPatternSyntax.self),
+              case .identifier(let name) = identifierPattern.identifier.tokenKind else {
+            return nil
+        }
+        return name
+    }
+
+    /// Returns the first binding with a `pattern` of type
+    /// `type`.
+    func firstPatternOf<T: PatternSyntaxProtocol>(_ type: T.Type) -> T? {
+        let result = self.bindings.first { patternBinding in
+            patternBinding.pattern.as(type) != nil
+        }
+        return result?.pattern.as(type)
+    }
+}

Source/SwiftLintBuiltInRules/Rules/Idiomatic/ReduceIntoInsteadOfLoopRuleModels.swift

@@ -0,0 +1,55 @@
+import SwiftSyntax
+
+struct ReduceIntoInsteadOfLoopRuleModels {}
+
+internal extension ReduceIntoInsteadOfLoopRule {
+    struct ReferencedVariable: Hashable {
+        let name: String
+        let position: AbsolutePosition
+        let kind: Kind
+
+        func hash(into hasher: inout Hasher) {
+            hasher.combine(self.name)
+            hasher.combine(self.position.utf8Offset)
+            hasher.combine(self.kind)
+        }
+    }
+
+    enum Kind: Hashable {
+        case method(name: String, arguments: Int)
+        case assignment(subscript: Bool)
+
+        func hash(into hasher: inout Hasher) {
+            switch self {
+            case let .method(name, arguments):
+                hasher.combine("method")
+                hasher.combine(name)
+                hasher.combine(arguments)
+            case let .assignment(`subscript`):
+                hasher.combine("assignment")
+                hasher.combine(`subscript`)
+            }
+        }
+    }
+
+    struct CollectionType: Hashable {
+        let name: String
+        let genericArguments: Int
+
+        static let types: [Self] = [
+            .set,
+            .array,
+            .dictionary,
+        ]
+
+        static let array = Self(name: "Array", genericArguments: 1)
+        static let set = Self(name: "Set", genericArguments: 1)
+        static let dictionary = Self(name: "Dictionary", genericArguments: 2)
+
+        static let names: [String: Self] = {
+            Self.types.reduce(into: [String: Self]()) { partialResult, collectionType in
+                partialResult[collectionType.name] = collectionType
+            }
+        }()
+    }
+}

Tests/GeneratedTests/GeneratedTests.swift

@@ -1009,6 +1009,12 @@ final class ReduceBooleanRuleGeneratedTests: SwiftLintTestCase {
     }
 }
 
+final class ReduceIntoInsteadOfLoopRuleGeneratedTests: SwiftLintTestCase {
+    func testWithDefaultConfiguration() {
+        verifyRule(ReduceIntoInsteadOfLoopRule.description)
+    }
+}
+
 final class ReduceIntoRuleGeneratedTests: SwiftLintTestCase {
     func testWithDefaultConfiguration() {
         verifyRule(ReduceIntoRule.description)

Tests/IntegrationTests/default_rule_configurations.yml

@@ -964,6 +964,11 @@ reduce_into:
   meta:
     opt-in: true
     correctable: false
+reduce_into_instead_of_loop:
+  severity: warning
+  meta:
+    opt-in: true
+    correctable: false
 redundant_discardable_let:
   severity: warning
   ignore_swiftui_view_bodies: false