Correctly handle init accessor

Sources/FormattingHelpers.swift

@@ -2870,7 +2870,7 @@ extension Formatter {
                         ["static", "class"].contains(string)
                     })
                     if let name = name, classOrStatic || !staticSelf {
-                        processAccessors(["get", "set", "willSet", "didSet"], for: name,
+                        processAccessors(["get", "set", "willSet", "didSet", "init"], for: name,
                                          at: &index, localNames: localNames, members: members,
                                          typeStack: &typeStack, closureStack: &closureStack,
                                          membersByType: &membersByType,
@@ -3160,8 +3160,15 @@ extension Formatter {
             assert(tokens[index] == .startOfScope("{"))
             var foundAccessors = false
             var localNames = localNames
-            while let nextIndex = self.index(of: .nonSpaceOrCommentOrLinebreak, after: index, if: {
-                if case let .identifier(name) = $0, names.contains(name) { return true } else { return false }
+            while var nextIndex = self.index(of: .nonSpaceOrCommentOrLinebreak, after: index, if: {
+                switch $0 {
+                case .keyword where $0.isAttribute:
+                    return true
+                case let .identifier(name), let .keyword(name):
+                    return names.contains(name)
+                default:
+                    return false
+                }
             }), let startIndex = self.index(of: .startOfScope("{"), after: nextIndex) {
                 foundAccessors = true
                 index = startIndex + 1
@@ -3170,10 +3177,18 @@ extension Formatter {
                 }), let varToken = next(.identifier, after: parenStart) {
                     localNames.insert(varToken.unescaped())
                 } else {
-                    switch tokens[nextIndex].string {
+                    var token = tokens[nextIndex]
+                    while token.isAttribute,
+                          let endIndex = endOfAttribute(at: nextIndex),
+                          let index = self.index(of: .nonSpaceOrCommentOrLinebreak, after: endIndex)
+                    {
+                        nextIndex = index
+                        token = tokens[nextIndex]
+                    }
+                    switch token.string {
                     case "get":
                         localNames.insert(name)
-                    case "set":
+                    case "set", "init":
                         localNames.insert(name)
                         localNames.insert("newValue")
                     case "willSet":

Sources/Inference.swift

@@ -994,7 +994,7 @@ private struct Inference {
                         prevIndex -= 1
                     }
                     if let name = name {
-                        processAccessors(["get", "set", "willSet", "didSet"], for: name,
+                        processAccessors(["get", "set", "willSet", "didSet", "init"], for: name,
                                          at: &index, localNames: localNames, members: members,
                                          typeStack: &typeStack, membersByType: &membersByType,
                                          classMembersByType: &classMembersByType,

Sources/ParsingHelpers.swift

@@ -668,7 +668,7 @@ extension Formatter {
 
     func isAccessorKeyword(at i: Int, checkKeyword: Bool = true) -> Bool {
         guard !checkKeyword ||
-            ["get", "set", "willSet", "didSet"].contains(token(at: i)?.string ?? ""),
+            ["get", "set", "willSet", "didSet", "init"].contains(token(at: i)?.string ?? ""),
             var prevIndex = index(of: .nonSpaceOrCommentOrLinebreak, before: i)
         else {
             return false
@@ -1120,7 +1120,7 @@ extension Formatter {
                     return true
                 }
                 return false
-            case "get", "set", "willSet", "didSet":
+            case "get", "set", "willSet", "didSet", "init":
                 return isAccessorKeyword(at: i, checkKeyword: false)
             case "actor":
                 if last(.nonSpaceOrCommentOrLinebreak, before: i)?.isOperator(ofType: .infix) == true {

Tests/ParsingHelpersTests.swift

@@ -625,6 +625,18 @@ class ParsingHelpersTests: XCTestCase {
         XCTAssert(formatter.isAccessorKeyword(at: 34))
     }
 
+    func testInit() {
+        let formatter = Formatter(tokenize("""
+        var foo: Int {
+            init {}
+            get {}
+            set {}
+        }
+        """))
+        XCTAssert(formatter.isAccessorKeyword(at: 10))
+        XCTAssert(formatter.isAccessorKeyword(at: 16))
+    }
+
     func testNotGetter() {
         let formatter = Formatter(tokenize("""
         func foo() {
@@ -644,6 +656,15 @@ class ParsingHelpersTests: XCTestCase {
         XCTAssert(formatter.isAccessorKeyword(at: 10, checkKeyword: false))
     }
 
+    func testNotSetterInit() {
+        let formatter = Formatter(tokenize("""
+        class Foo {
+            init() { print("") }
+        }
+        """))
+        XCTAssertFalse(formatter.isAccessorKeyword(at: 7))
+    }
+
     // MARK: isEnumCase
 
     func testIsEnumCase() {

Tests/RulesTests+Redundancy.swift

@@ -6230,6 +6230,50 @@ class RedundancyTests: RulesTests {
         testFormatting(for: input, rule: FormatRules.redundantSelf, options: options)
     }
 
+    func testPropertyInitNotInterpretedAsTypeInit() {
+        let input = """
+        struct MyStruct {
+            private var __myVar: String
+            var myVar: String {
+                @storageRestrictions(initializes: __myVar)
+                init(initialValue) {
+                    __myVar = initialValue
+                }
+                set {
+                    __myVar = newValue
+                }
+                get {
+                    __myVar
+                }
+            }
+        }
+        """
+        let options = FormatOptions(explicitSelf: .initOnly)
+        testFormatting(for: input, rule: FormatRules.redundantSelf, options: options)
+    }
+
+    func testPropertyInitNotInterpretedAsTypeInit2() {
+        let input = """
+        struct MyStruct {
+            private var __myVar: String
+            var myVar: String {
+                @storageRestrictions(initializes: __myVar)
+                init {
+                    __myVar = newValue
+                }
+                set {
+                    __myVar = newValue
+                }
+                get {
+                    __myVar
+                }
+            }
+        }
+        """
+        let options = FormatOptions(explicitSelf: .initOnly)
+        testFormatting(for: input, rule: FormatRules.redundantSelf, options: options)
+    }
+
     // parsing bugs
 
     func testSelfRemovalParsingBug() {