Update propertyTypes rule to support Set literal initialization, in addition to arrays and dictionaries (#2189)

Author: calda

Sources/Rules/PropertyTypes.swift

@@ -157,6 +157,16 @@ public extension FormatRule {
                     formatter.replaceTokens(in: rhsExpressionRange, with: tokenize("\(type.string)()"))
                 }
 
+                // Convert `let set: Set<Foo> = []` to `let set = Set<Foo>()`
+                else if type.isSet,
+                        formatter.tokens[rhsStartIndex] == .startOfScope("["),
+                        let nextToken = formatter.index(of: .nonSpaceOrCommentOrLinebreak, after: rhsStartIndex),
+                        formatter.tokens[nextToken] == .endOfScope("]"),
+                        rhsExpressionRange.upperBound == nextToken
+                {
+                    formatter.replaceTokens(in: rhsExpressionRange, with: tokenize("\(type.string)()"))
+                }
+
                 else {
                     return
                 }
@@ -218,6 +228,11 @@ public extension FormatRule {
                         formatter.replaceTokens(in: indexAfterType ... endOfInitCallScope, with: tokenize("[:]"))
                     }
 
+                    // If this is an empty set initializer, use `[]` instead of `.init()`
+                    else if rhsType.isSet, initializerHasNoArguments {
+                        formatter.replaceTokens(in: indexAfterType ... endOfInitCallScope, with: tokenize("[]"))
+                    }
+
                     else {
                         formatter.insert([.operator(".", .prefix), .identifier("init")], at: indexAfterType)
                     }

Sources/TypeName.swift

@@ -80,19 +80,37 @@ extension TypeName {
         return !hasColonInBraces
     }
 
-    /// Whether or not this type is an array.
+    /// Whether or not this type is a dictionary.
     var isDictionary: Bool {
         guard let openBrace = formatter.index(of: .nonSpaceOrCommentOrLinebreak, after: range.lowerBound - 1),
               formatter.tokens[openBrace] == .startOfScope("["),
               let closingBrace = formatter.endOfScope(at: openBrace),
               openBrace + 1 != closingBrace
         else { return false }
 
-        // [] would be a dictionary, not an array
+        // [] would be an array, not a dictionary
         let hasColonInBraces = formatter.index(of: .delimiter(":"), in: (openBrace + 1) ..< closingBrace) != nil
         return hasColonInBraces
     }
 
+    /// Whether or not this type is a generic type with the given name.
+    func isGenericType(named typeName: String) -> Bool {
+        guard let firstToken = formatter.index(of: .nonSpaceOrCommentOrLinebreak, after: range.lowerBound - 1),
+              formatter.tokens[firstToken] == .identifier(typeName),
+              let openAngleBrace = formatter.index(of: .nonSpaceOrCommentOrLinebreak, after: firstToken),
+              formatter.tokens[openAngleBrace] == .startOfScope("<"),
+              let closingAngleBrace = formatter.endOfScope(at: openAngleBrace),
+              openAngleBrace + 1 != closingAngleBrace
+        else { return false }
+
+        return true
+    }
+
+    /// Whether or not this type is a set.
+    var isSet: Bool {
+        isGenericType(named: "Set")
+    }
+
     /// Whether or not this type is a closure
     var isClosure: Bool {
         formatter.isStartOfClosureType(at: range.lowerBound)

Tests/Rules/PropertyTypesTests.swift

@@ -703,4 +703,36 @@ class PropertyTypesTests: XCTestCase {
         let options = FormatOptions(propertyTypes: .inferred)
         testFormatting(for: input, output, rule: .propertyTypes, options: options)
     }
+
+    func testEmptySetLiteralToInferredType() {
+        let input = """
+        let set: Set<Int> = []
+        var strings: Set<String> = []
+        let nested: Set<Set<Bool>> = []
+        """
+        let output = """
+        let set = Set<Int>()
+        var strings = Set<String>()
+        let nested = Set<Set<Bool>>()
+        """
+        let options = FormatOptions(propertyTypes: .inferred)
+        testFormatting(for: input, output, rule: .propertyTypes, options: options)
+    }
+
+    func testEmptySetInitToSetLiteral() {
+        let input = """
+        let set = Set<Foo>()
+        var mapping = Set<String>()
+        let nested = Set<Set<Int>>()
+        let capacitySet = Set<Int>(minimumCapacity: 10)
+        """
+        let output = """
+        let set: Set<Foo> = []
+        var mapping: Set<String> = []
+        let nested: Set<Set<Int>> = []
+        let capacitySet: Set<Int> = .init(minimumCapacity: 10)
+        """
+        let options = FormatOptions(propertyTypes: .explicit)
+        testFormatting(for: input, output, rule: .propertyTypes, options: options)
+    }
 }