Fix of in fixed-size arrays being mistaken for an identifier

Author: nicklockwood

Sources/ParsingHelpers.swift

@@ -389,14 +389,14 @@ extension Formatter {
 
     /// Returns true if the token at specified index is a modifier
     func isModifier(at index: Int) -> Bool {
-        guard let token = token(at: index), token._isModifierKeyword else {
+        guard let token = token(at: index), token.isModifierKeyword else {
             return false
         }
 
         if token == .keyword("class"),
            let nextToken = next(.nonSpaceOrCommentOrLinebreak, after: index)
         {
-            return nextToken.isDeclarationTypeKeyword || nextToken._isModifierKeyword
+            return nextToken.isDeclarationTypeKeyword || nextToken.isModifierKeyword
         }
 
         // Async is only a valid modifier on local let/var declarations.
@@ -2536,7 +2536,7 @@ extension Formatter {
                 if nextToken.isDeclarationTypeKeyword {
                     return nextToken.string
                 }
-                guard nextToken._isModifierKeyword else {
+                guard nextToken.isModifierKeyword else {
                     break
                 }
                 nextIndex = i
@@ -3652,12 +3652,22 @@ extension Token {
     /// This doesn't necessarily mean that the keyword is a modifier: some modifiers
     /// like `class` and `async` are contextual.
     /// In rule implementations, prefer using the `Formatter.isModifier(at:)` helper.
-    var _isModifierKeyword: Bool {
+    var isModifierKeyword: Bool {
         switch self {
         case let .keyword(keyword), let .identifier(keyword):
             return _FormatRules.allModifiers.contains(keyword)
         default:
             return false
         }
     }
+
+    /// These identifiers are treated as keywords when used in a type position
+    var isKeywordInTypeContext: Bool {
+        switch self {
+        case let .keyword(keyword), let .identifier(keyword):
+            return ["borrowing", "consuming", "isolated", "sending", "some", "any", "of"].contains(keyword)
+        default:
+            return false
+        }
+    }
 }

Sources/Rules/SpaceAroundBrackets.swift

@@ -25,19 +25,14 @@ public extension FormatRule {
                 return
             }
             switch prevToken {
-            case .keyword,
-                 .identifier("borrowing") where formatter.isTypePosition(at: index),
-                 .identifier("consuming") where formatter.isTypePosition(at: index),
-                 .identifier("sending") where formatter.isTypePosition(at: index):
+            case .identifier where prevToken.isKeywordInTypeContext && formatter.isTypePosition(at: index), .keyword:
                 formatter.insert(.space(" "), at: i)
             case .space:
                 let index = i - 2
                 if let token = formatter.token(at: index) {
                     switch token {
                     case .identifier("as"), .identifier("is"), // not treated as keywords inside macro
-                         .identifier("borrowing") where formatter.isTypePosition(at: index),
-                         .identifier("consuming") where formatter.isTypePosition(at: index),
-                         .identifier("sending") where formatter.isTypePosition(at: index),
+                         .identifier where token.isKeywordInTypeContext && formatter.isTypePosition(at: index),
                          .identifier("try"), .keyword("try"):
                         break
                     case .identifier, .number, .endOfScope("]"), .endOfScope("}"), .endOfScope(")"):

Sources/Rules/SpaceAroundOperators.swift

@@ -37,7 +37,7 @@ public extension FormatRule {
                 default:
                     formatter.insert(.space(" "), at: i + 1)
                 }
-            case .operator("?", .postfix), .operator("!", .postfix):
+            case let token where token.isUnwrapOperator:
                 if let prevToken = formatter.token(at: i - 1),
                    formatter.token(at: i + 1)?.isSpaceOrLinebreak == false,
                    [.keyword("as"), .keyword("try")].contains(prevToken)

Sources/Rules/SpaceAroundParens.swift

@@ -30,25 +30,15 @@ public extension FormatRule {
                 fallthrough
             case .endOfScope("]") where formatter.isInClosureArguments(at: index),
                  .endOfScope(")") where formatter.isAttribute(at: index),
-                 .identifier("some") where formatter.isTypePosition(at: index),
-                 .identifier("any") where formatter.isTypePosition(at: index),
-                 .identifier("borrowing") where formatter.isTypePosition(at: index),
-                 .identifier("consuming") where formatter.isTypePosition(at: index),
-                 .identifier("isolated") where formatter.isTypePosition(at: index),
-                 .identifier("sending") where formatter.isTypePosition(at: index):
+                 .identifier where prevToken.isKeywordInTypeContext && formatter.isTypePosition(at: index):
                 formatter.insert(.space(" "), at: i)
             case .space:
                 let index = i - 2
                 guard let token = formatter.token(at: index) else {
                     return
                 }
                 switch token {
-                case .identifier("some") where formatter.isTypePosition(at: index),
-                     .identifier("any") where formatter.isTypePosition(at: index),
-                     .identifier("borrowing") where formatter.isTypePosition(at: index),
-                     .identifier("consuming") where formatter.isTypePosition(at: index),
-                     .identifier("isolated") where formatter.isTypePosition(at: index),
-                     .identifier("sending") where formatter.isTypePosition(at: index):
+                case .identifier where token.isKeywordInTypeContext && formatter.isTypePosition(at: index):
                     break
                 case let .keyword(string) where !formatter.spaceAfter(string, index: index):
                     fallthrough

Sources/Tokenizer.swift

@@ -38,7 +38,7 @@ import Foundation
 /// behave like identifiers. So too have context-specific keywords such as the following:
 /// any, associativity, async, convenience, didSet, dynamic, final, get, indirect, infix, lazy,
 /// left, mutating, none, nonmutating, open, optional, override, postfix, precedence,
-/// prefix, Protocol, required, right, set, some, any, Type, unowned, weak, willSet
+/// prefix, Protocol, required, right, set, some, any, of, Type, unowned, weak, willSet
 let swiftKeywords = Set([
     "let", "return", "func", "var", "if", "public", "as", "else", "in", "import",
     "class", "try", "guard", "case", "for", "init", "extension", "private", "static",

Tests/Rules/SpaceAroundBracketsTests.swift

@@ -34,6 +34,30 @@ final class SpaceAroundBracketsTests: XCTestCase {
         testFormatting(for: input, rule: .spaceAroundBrackets)
     }
 
+    func testSpaceNotRemovedAfterOfArray() {
+        let input = """
+        let foo: [4 of [String]]
+        """
+        testFormatting(for: input, rule: .spaceAroundBrackets)
+    }
+
+    func testSpaceAddedAfterOfArray() {
+        let input = """
+        let foo: [4 of[String]]
+        """
+        let output = """
+        let foo: [4 of [String]]
+        """
+        testFormatting(for: input, output, rule: .spaceAroundBrackets)
+    }
+
+    func testOfIdentifierBracketSpacing() {
+        let input = """
+        if foo.of[String.self] {}
+        """
+        testFormatting(for: input, rule: .spaceAroundBrackets)
+    }
+
     func testAsArrayCastingSpacing() {
         let input = """
         foo as[String]
@@ -61,9 +85,9 @@ final class SpaceAroundBracketsTests: XCTestCase {
         testFormatting(for: input, output, rule: .spaceAroundBrackets)
     }
 
-    func testKeywordAsIdentifierBracketSpacing() {
+    func testIsIdentifierBracketSpacing() {
         let input = """
-        if foo.is[String] {}
+        if foo.is[String.self] {}
         """
         testFormatting(for: input, rule: .spaceAroundBrackets)
     }

Tests/Rules/SpaceAroundParensTests.swift

@@ -536,4 +536,65 @@ final class SpaceAroundParensTests: XCTestCase {
         """
         testFormatting(for: input, output, rule: .spaceAroundParens)
     }
+
+    func testOfTupleSpacing() {
+        let input = """
+        let foo: [4 of(String, Int)]
+        """
+        let output = """
+        let foo: [4 of (String, Int)]
+        """
+        testFormatting(for: input, output, rule: .spaceAroundParens)
+    }
+
+    func testOfIdentifierParenSpacing() {
+        let input = """
+        if foo.of(String.self) {}
+        """
+        testFormatting(for: input, rule: .spaceAroundParens)
+    }
+
+    func testAsTupleCastingSpacing() {
+        let input = """
+        foo as(String, Int)
+        """
+        let output = """
+        foo as (String, Int)
+        """
+        testFormatting(for: input, output, rule: .spaceAroundParens)
+    }
+
+    func testAsOptionalTupleCastingSpacing() {
+        let input = """
+        foo as? (String, Int)
+        """
+        testFormatting(for: input, rule: .spaceAroundParens)
+    }
+
+    func testIsTupleTestingSpacing() {
+        let input = """
+        if foo is(String, Int) {}
+        """
+        let output = """
+        if foo is (String, Int) {}
+        """
+        testFormatting(for: input, output, rule: .spaceAroundParens)
+    }
+
+    func testIsIdentifierParenSpacing() {
+        let input = """
+        if foo.is(String.self, Int.self) {}
+        """
+        testFormatting(for: input, rule: .spaceAroundParens)
+    }
+
+    func testSpaceBeforeTupleIndexCall() {
+        let input = """
+        foo.1 (2)
+        """
+        let output = """
+        foo.1(2)
+        """
+        testFormatting(for: input, output, rule: .spaceAroundParens)
+    }
 }