Fix false positive in implicit_getter with Swift 5.2

Fixes #3074

CHANGELOG.md

@@ -80,6 +80,11 @@
 * Implicit_return description now reports current config correctly.
   [John Buckley](https://github.com/nhojb)
 
+* Fix false positive in `implicit_getter` rule in extensions when using
+  Swift 5.2.  
+  [Marcelo Fabri](https://github.com/marcelofabri)
+  [#3074](https://github.com/realm/SwiftLint/issues/3074)
+
 * Do not trigger `optional_enum_case_matching` rule on `_?` as the `?` might
   be required in some situations.  
   [Marcelo Fabri](https://github.com/marcelofabri)

Source/SwiftLintFramework/Models/SwiftVersion.swift

@@ -29,6 +29,8 @@ public extension SwiftVersion {
     static let five = SwiftVersion(rawValue: "5.0.0")
     /// Swift 5.1.x - https://swift.org/download/#swift-51
     static let fiveDotOne = SwiftVersion(rawValue: "5.1.0")
+    /// Swift 5.2.x - https://swift.org/download/#swift-52
+    static let fiveDotTwo = SwiftVersion(rawValue: "5.2.0")
 
     /// The current detected Swift compiler version, based on the currently accessible SourceKit version.
     ///

Source/SwiftLintFramework/Rules/Style/ImplicitGetterRule.swift

@@ -15,18 +15,7 @@ public struct ImplicitGetterRule: ConfigurationProviderRule, AutomaticTestableRu
     )
 
     public func validate(file: SwiftLintFile) -> [StyleViolation] {
-        let pattern = "\\{[^\\{]*?\\s+get\\b"
-        let attributesKinds: Set<SyntaxKind> = [.attributeBuiltin, .attributeID]
-        let getTokens: [SwiftLintSyntaxToken] = file.rangesAndTokens(matching: pattern).compactMap { _, tokens in
-            let kinds = tokens.kinds
-            guard let token = tokens.last,
-                token.kind == .keyword,
-                attributesKinds.isDisjoint(with: kinds) else {
-                    return nil
-            }
-
-            return token
-        }
+        let getTokens = findComputedPropertyToken(keyword: "get", file: file)
 
         let violatingLocations = getTokens.compactMap { token -> (ByteCount, SwiftDeclarationKind?)? in
             // the last element is the deepest structure
@@ -36,8 +25,29 @@ public struct ImplicitGetterRule: ConfigurationProviderRule, AutomaticTestableRu
             }
 
             // If there's a setter, `get` is allowed
-            guard dict.setterAccessibility == nil else {
-                return nil
+            if SwiftVersion.current < .fiveDotTwo || dict.accessibility != nil {
+                guard dict.setterAccessibility == nil else {
+                    return nil
+                }
+            } else {
+                guard let range = dict.bodyByteRange.map(file.stringView.byteRangeToNSRange) else {
+                    return nil
+                }
+
+                let setTokens = findComputedPropertyToken(keyword: "set", file: file, range: range)
+                let hasSetToken = setTokens.contains { token in
+                    // the last element is the deepest structure
+                    guard let setDict = declarations(forByteOffset: token.offset,
+                                                     structureDictionary: file.structureDictionary).last else {
+                        return false
+                    }
+
+                    return setDict.offset == dict.offset
+                }
+
+                guard !hasSetToken else {
+                    return nil
+                }
             }
 
             let kind = dict.declarationKind
@@ -56,6 +66,22 @@ public struct ImplicitGetterRule: ConfigurationProviderRule, AutomaticTestableRu
                                   reason: reason)
         }
     }
+
+    private func findComputedPropertyToken(keyword: String, file: SwiftLintFile,
+                                           range: NSRange? = nil) -> [SwiftLintSyntaxToken] {
+        let pattern = "\\{[^\\{]*?\\s+\(keyword)\\b"
+        let attributesKinds: Set<SyntaxKind> = [.attributeBuiltin, .attributeID]
+        return file.rangesAndTokens(matching: pattern, range: range).compactMap { _, tokens in
+            let kinds = tokens.kinds
+            guard let token = tokens.last,
+                token.kind == .keyword,
+                attributesKinds.isDisjoint(with: kinds) else {
+                    return nil
+            }
+
+            return token
+        }
+    }
 }
 
 private extension ImplicitGetterRule {

Source/SwiftLintFramework/Rules/Style/ImplicitGetterRuleExamples.swift

@@ -84,6 +84,22 @@ struct ImplicitGetterRuleExamples {
                     return self.count
                 }
             }
+            """),
+            Example("""
+            extension Foo {
+                var bar: Bool {
+                    get { _bar }
+                    set { self._bar = newValue }
+                }
+            }
+            """),
+            Example("""
+            extension Foo {
+                var bar: Bool {
+                    get { _bar }
+                    set(newValue) { self._bar = newValue }
+                }
+            }
             """)
         ]
 
@@ -161,6 +177,13 @@ struct ImplicitGetterRuleExamples {
                     }
                 }
             }
+            """),
+            Example("""
+            extension Foo {
+                var bar: Bool {
+                    ↓get { _bar }
+                }
+            }
             """)
         ]