Fix another bug with parsing guard case statements

Author: nicklockwood

Sources/FormattingHelpers.swift

@@ -33,7 +33,8 @@ extension Formatter {
         while let token = self.token(at: index) {
             switch token {
             case .identifier where
-                last(.nonSpaceOrCommentOrLinebreak, before: index)?.isOperator(".") == false:
+                last(.nonSpaceOrCommentOrLinebreak, before: index)?.isOperator(".") == false &&
+                next(.nonSpaceOrCommentOrLinebreak, after: index)?.isOperator(".") == false:
                 let name = token.unescaped()
                 if name != "_", declarationIndex != nil || !isConditional {
                     names.insert(name)

Sources/Rules.swift

@@ -2876,12 +2876,15 @@ public struct _FormatRules {
                             index = nextIndex
                         }
                         lastKeyword = ""
-                    case "if", "while", "guard":
+                    case "if", "while", "guard", "for":
                         assert(!isTypeRoot)
                         // Guard is included because it's an error to reference guard vars in body
                         var scopedNames = localNames
                         formatter.processDeclaredVariables(at: &index, names: &scopedNames,
                                                            removeSelf: explicitSelf != .insert)
+                        if scopeStack.last == .startOfScope("(") {
+                            scopeStack.removeLast()
+                        }
                         guard let startIndex = formatter.index(of: .startOfScope("{"), after: index) else {
                             return formatter.fatalError("Expected {", at: index)
                         }
@@ -2890,6 +2893,8 @@ public struct _FormatRules {
                                     membersByType: &membersByType, classMembersByType: &classMembersByType,
                                     usingDynamicLookup: usingDynamicLookup, isTypeRoot: false, isInit: isInit)
                         lastKeyword = ""
+                    case "case" where ["if", "while", "guard", "for"].contains(lastKeyword):
+                        break
                     default:
                         lastKeyword = token.string
                     }

Tests/RulesTests+Redundancy.swift

@@ -2711,6 +2711,77 @@ extension RulesTests {
         testFormatting(for: input, rule: FormatRules.redundantSelf)
     }
 
+    func testNoRemoveSelfAfterGuardCaseLetWithExplicitNamespace() {
+        let input = """
+        class Foo {
+            var name: String?
+
+            func bug(element: Something) {
+                guard case let Something.a(name) = element
+                else { return }
+                self.name = name
+            }
+        }
+        """
+        testFormatting(for: input, rule: FormatRules.redundantSelf)
+    }
+
+    func testRedundantSelfParsingBug() {
+        let input = """
+        private class Foo {
+            mutating func bar() -> Statement? {
+                let start = self
+                guard case Token.identifier(let name)? = self.popFirst() else {
+                    self = start
+                    return nil
+                }
+                return Statement.declaration(name: name)
+            }
+        }
+        """
+        let output = """
+        private class Foo {
+            mutating func bar() -> Statement? {
+                let start = self
+                guard case Token.identifier(let name)? = popFirst() else {
+                    self = start
+                    return nil
+                }
+                return Statement.declaration(name: name)
+            }
+        }
+        """
+        testFormatting(for: input, output, rule: FormatRules.redundantSelf,
+                       exclude: ["hoistPatternLet"])
+    }
+
+    func testRedundantSelfParsingBug2() {
+        let input = """
+        extension Foo {
+            private enum NonHashableEnum: RawRepresentable {
+                case foo
+                case bar
+
+                var rawValue: RuntimeTypeTests.TestStruct {
+                    return TestStruct(foo: 0)
+                }
+
+                init?(rawValue: RuntimeTypeTests.TestStruct) {
+                    switch rawValue.foo {
+                    case 0:
+                        self = .foo
+                    case 1:
+                        self = .bar
+                    default:
+                        return nil
+                    }
+                }
+            }
+        }
+        """
+        testFormatting(for: input, rule: FormatRules.redundantSelf)
+    }
+
     // explicitSelf = .insert
 
     func testInsertSelf() {

Tests/XCTestManifests.swift

@@ -1332,6 +1332,7 @@ extension RulesTests {
         ("testNoRemoveReturnInSubscript", testNoRemoveReturnInSubscript),
         ("testNoRemoveReturnInTupleVarGetter", testNoRemoveReturnInTupleVarGetter),
         ("testNoRemoveSelfAfterGenericInit", testNoRemoveSelfAfterGenericInit),
+        ("testNoRemoveSelfAfterGuardCaseLetWithExplicitNamespace", testNoRemoveSelfAfterGuardCaseLetWithExplicitNamespace),
         ("testNoRemoveSelfAfterGuardLetSelf", testNoRemoveSelfAfterGuardLetSelf),
         ("testNoRemoveSelfAfterOptionalReturn", testNoRemoveSelfAfterOptionalReturn),
         ("testNoRemoveSelfBeforeInit", testNoRemoveSelfBeforeInit),
@@ -1654,6 +1655,8 @@ extension RulesTests {
         ("testRedundantReturnInVoidFunction3", testRedundantReturnInVoidFunction3),
         ("testRedundantReturnInVoidFunction4", testRedundantReturnInVoidFunction4),
         ("testRedundantSelfDoesntGetStuckIfNoParensFound", testRedundantSelfDoesntGetStuckIfNoParensFound),
+        ("testRedundantSelfParsingBug", testRedundantSelfParsingBug),
+        ("testRedundantSelfParsingBug2", testRedundantSelfParsingBug2),
         ("testRedundantSelfRemovedInsideConditionalCase", testRedundantSelfRemovedInsideConditionalCase),
         ("testRedundantSelfRemovedWhenFollowedBySwitchContainingIfdef", testRedundantSelfRemovedWhenFollowedBySwitchContainingIfdef),
         ("testRedundantSelfRuleDoesntErrorForClassFuncInClassWithWhere", testRedundantSelfRuleDoesntErrorForClassFuncInClassWithWhere),