Add option allow_redundancy to rule explicit_type_interface

CHANGELOG.md

@@ -35,6 +35,11 @@
 * Add `private_only` configuration to `prefixed_toplevel_constant` rule  
   [Keith Smiley](https://github.com/keith)
   [#2315](https://github.com/realm/SwiftLint/pull/2315)
+
+* Make rule `explicit_type_interface` compatible with rule
+  `redundant_type_annotation`.  
+  [Cihat Gündüz](https://github.com/Dschee)
+  [#2312](https://github.com/realm/SwiftLint/issues/2312)
 
 #### Bug Fixes
 

Rules.md

@@ -4939,6 +4939,20 @@ class Foo {
 
 ```
 
+```swift
+class Foo {
+  ↓let myVar = Int(0)
+}
+
+```
+
+```swift
+class Foo {
+  ↓let myVar = Set<Int>(0)
+}
+
+```
+
 </details>
 
 

Source/SwiftLintFramework/Rules/ExplicitTypeInterfaceRule.swift

@@ -21,7 +21,9 @@ public struct ExplicitTypeInterfaceRule: ASTRule, OptInRule, ConfigurationProvid
             "class Foo {\n  ↓var myVar = 0\n\n}\n",
             "class Foo {\n  ↓let mylet = 0\n\n}\n",
             "class Foo {\n  ↓static var myStaticVar = 0\n}\n",
-            "class Foo {\n  ↓class var myClassVar = 0\n}\n"
+            "class Foo {\n  ↓class var myClassVar = 0\n}\n",
+            "class Foo {\n  ↓let myVar = Int(0)\n}\n",
+            "class Foo {\n  ↓let myVar = Set<Int>(0)\n}\n"
         ]
     )
 
@@ -30,6 +32,7 @@ public struct ExplicitTypeInterfaceRule: ASTRule, OptInRule, ConfigurationProvid
 
         guard configuration.allowedKinds.contains(kind),
             !containsType(dictionary: dictionary),
+            (!configuration.allowRedundancy || !assigneeIsInitCall(file: file, dictionary: dictionary)),
             let offset = dictionary.offset else {
                 return []
         }
@@ -44,4 +47,19 @@ public struct ExplicitTypeInterfaceRule: ASTRule, OptInRule, ConfigurationProvid
     private func containsType(dictionary: [String: SourceKitRepresentable]) -> Bool {
         return dictionary.typeName != nil
     }
+
+    private func assigneeIsInitCall(file: File, dictionary: [String: SourceKitRepresentable]) -> Bool {
+        guard
+            let nameOffset = dictionary.nameOffset,
+            let nameLength = dictionary.nameLength,
+            let afterNameRange = file.contents.bridge().byteRangeToNSRange(start: nameOffset + nameLength, length: 0)
+        else {
+            return false
+        }
+
+        let contentAfterName = file.contents.bridge().substring(from: afterNameRange.location)
+        let initCallRegex = regex("^\\s*=\\s*\\p{Lu}[^\\(\\s<]*(?:<[^\\>]*>)?\\(")
+
+        return initCallRegex.firstMatch(in: contentAfterName, options: [], range: contentAfterName.fullNSRange) != nil
+    }
 }

Source/SwiftLintFramework/Rules/RuleConfigurations/ExplicitTypeInterfaceConfiguration.swift

@@ -45,14 +45,18 @@ public struct ExplicitTypeInterfaceConfiguration: RuleConfiguration, Equatable {
                                                                    .varStatic,
                                                                    .varClass]
 
-    public var severityConfiguration = SeverityConfiguration(.warning)
+    private(set) var severityConfiguration = SeverityConfiguration(.warning)
 
-    public var allowedKinds = ExplicitTypeInterfaceConfiguration.variableKinds
+    private(set) var allowedKinds = ExplicitTypeInterfaceConfiguration.variableKinds
+
+    private(set) var allowRedundancy = false
 
     public var consoleDescription: String {
         let excludedKinds = ExplicitTypeInterfaceConfiguration.variableKinds.subtracting(allowedKinds)
         let simplifiedExcludedKinds = excludedKinds.compactMap { $0.variableKind?.rawValue }.sorted()
-        return severityConfiguration.consoleDescription + ", excluded: \(simplifiedExcludedKinds)"
+        return severityConfiguration.consoleDescription +
+            ", excluded: \(simplifiedExcludedKinds)" +
+            ", allow_redundancy: \(allowRedundancy)"
     }
 
     public init() {}
@@ -68,6 +72,8 @@ public struct ExplicitTypeInterfaceConfiguration: RuleConfiguration, Equatable {
             case ("excluded", let excludedStrings as [String]):
                 let excludedKinds = excludedStrings.compactMap(VariableKind.init(rawValue:))
                 allowedKinds.subtract(excludedKinds.map(SwiftDeclarationKind.init(variableKind:)))
+            case ("allow_redundancy", let allowRedundancy as Bool):
+                self.allowRedundancy = allowRedundancy
             default:
                 throw ConfigurationError.unknownConfiguration
             }

Tests/LinuxMain.swift

@@ -341,7 +341,8 @@ extension ExplicitTypeInterfaceRuleTests {
     static var allTests: [(String, (ExplicitTypeInterfaceRuleTests) -> () throws -> Void)] = [
         ("testExplicitTypeInterface", testExplicitTypeInterface),
         ("testExcludeLocalVars", testExcludeLocalVars),
-        ("testExcludeClassVars", testExcludeClassVars)
+        ("testExcludeClassVars", testExcludeClassVars),
+        ("testAllowRedundancy", testAllowRedundancy)
     ]
 }
 

Tests/SwiftLintFrameworkTests/ExplicitTypeInterfaceConfigurationTests.swift

@@ -12,9 +12,11 @@ class ExplicitTypeInterfaceConfigurationTests: XCTestCase {
     func testApplyingCustomConfiguration() throws {
         var config = ExplicitTypeInterfaceConfiguration()
         try config.apply(configuration: ["severity": "error",
-                                         "excluded": ["local"]])
+                                         "excluded": ["local"],
+                                         "allow_redundancy": true])
         XCTAssertEqual(config.severityConfiguration.severity, .error)
         XCTAssertEqual(config.allowedKinds, Set([.varInstance, .varClass, .varStatic]))
+        XCTAssertEqual(config.allowRedundancy, true)
     }
 
     func testInvalidKeyInCustomConfiguration() {
@@ -41,6 +43,9 @@ class ExplicitTypeInterfaceConfigurationTests: XCTestCase {
     func testConsoleDescription() throws {
         var config = ExplicitTypeInterfaceConfiguration()
         try config.apply(configuration: ["excluded": ["class", "instance"]])
-        XCTAssertEqual(config.consoleDescription, "warning, excluded: [\"class\", \"instance\"]")
+        XCTAssertEqual(
+            config.consoleDescription,
+            "warning, excluded: [\"class\", \"instance\"], allow_redundancy: false"
+        )
     }
 }

Tests/SwiftLintFrameworkTests/ExplicitTypeInterfaceRuleTests.swift

@@ -36,4 +36,26 @@ class ExplicitTypeInterfaceRuleTests: XCTestCase {
         verifyRule(description, ruleConfiguration: ["excluded": ["static"]])
     }
 
+    func testAllowRedundancy() {
+        let nonTriggeringExamples = [
+            "class Foo {\n  var myVar: Int? = 0\n}\n",
+            "class Foo {\n  let myVar: Int? = 0\n}\n",
+            "class Foo {\n  static var myVar: Int? = 0\n}\n",
+            "class Foo {\n  class var myVar: Int? = 0\n}\n",
+            "class Foo {\n  static let shared = Foo()\n}\n",
+            "class Foo {\n  let myVar = Int(0)\n}\n",
+            "class Foo {\n  let myVar = Set<Int>(0)\n}\n"
+        ]
+        let triggeringExamples = [
+            "class Foo {\n  ↓var myVar = 0\n\n}\n",
+            "class Foo {\n  ↓let mylet = 0\n\n}\n",
+            "class Foo {\n  ↓static var myStaticVar = 0\n}\n",
+            "class Foo {\n  ↓class var myClassVar = 0\n}\n"
+        ]
+        let description = ExplicitTypeInterfaceRule.description
+            .with(triggeringExamples: triggeringExamples)
+            .with(nonTriggeringExamples: nonTriggeringExamples)
+
+        verifyRule(description, ruleConfiguration: ["allow_redundancy": true])
+    }
 }