Update singlePropertyPerLine to preserve async let declarations (#2210)

Author: calda

Rules.md

@@ -1590,7 +1590,7 @@ Option | Description
 ```
 
 **NOTE:** If the `--modifier-order` option isn't set, the default order will be:
-`override`, `private`, `fileprivate`, `internal`, `package`, `public`, `open`, `private(set)`, `fileprivate(set)`, `internal(set)`, `package(set)`, `public(set)`, `open(set)`, `final`, `dynamic`, `optional`, `required`, `convenience`, `indirect`, `isolated`, `nonisolated`, `nonisolated(unsafe)`, `lazy`, `weak`, `unowned`, `unowned(safe)`, `unowned(unsafe)`, `static`, `class`, `borrowing`, `consuming`, `mutating`, `nonmutating`, `prefix`, `infix`, `postfix`
+`override`, `private`, `fileprivate`, `internal`, `package`, `public`, `open`, `private(set)`, `fileprivate(set)`, `internal(set)`, `package(set)`, `public(set)`, `open(set)`, `final`, `dynamic`, `optional`, `required`, `convenience`, `indirect`, `isolated`, `nonisolated`, `nonisolated(unsafe)`, `lazy`, `weak`, `unowned`, `unowned(safe)`, `unowned(unsafe)`, `static`, `class`, `borrowing`, `consuming`, `mutating`, `nonmutating`, `prefix`, `infix`, `postfix`, `async`
 
 </details>
 <br/>

Sources/ParsingHelpers.swift

@@ -1949,6 +1949,7 @@ extension Formatter {
         // Get declaration keyword
         var searchIndex = declarationKeywordIndex
         let declarationKeyword = declarationType(at: declarationKeywordIndex) ?? "#if"
+        var endOfDeclaration: Int?
         switch tokens[declarationKeywordIndex] {
         case .startOfScope("#if"):
             // For conditional compilation blocks, the `declarationKeyword` _is_ the `startOfScope`
@@ -1976,21 +1977,35 @@ extension Formatter {
         case .keyword("let"), .keyword("var"):
             if let propertyDeclaration = parsePropertyDeclaration(atIntroducerIndex: declarationKeywordIndex) {
                 searchIndex = propertyDeclaration.range.upperBound
+                endOfDeclaration = propertyDeclaration.range.upperBound
+            }
+        case .keyword("func"), .keyword("subscript"), .keyword("init"):
+            if let functionDeclaration = parseFunctionDeclaration(keywordIndex: declarationKeywordIndex) {
+                searchIndex = functionDeclaration.range.upperBound
+                endOfDeclaration = functionDeclaration.range.upperBound
             }
         default:
             break
         }
 
-        // Search for the next declaration so we know where this declaration ends.
-        let nextDeclarationKeywordIndex = index(after: searchIndex, where: {
-            $0.isDeclarationTypeKeyword || $0 == .startOfScope("#if")
-        })
+        // Search for the next declaration so we know where this declaration ends
+        // (the token before the first token of the following declaration).
 
-        // Search backward from the next declaration keyword to find where declaration begins.
-        var endOfDeclaration = nextDeclarationKeywordIndex.flatMap {
-            index(before: startOfModifiers(at: $0, includingAttributes: true), where: {
-                !$0.isSpaceOrCommentOrLinebreak
-            }).map { endOfLine(at: $0) }
+        if let nextDeclarationKeywordIndex = index(after: searchIndex, where: {
+            $0.isDeclarationTypeKeyword || $0 == .startOfScope("#if")
+        }),
+            let lastIndexBeforeNextDeclaration = index(
+                before: startOfModifiers(at: nextDeclarationKeywordIndex, includingAttributes: true),
+                where: { !$0.isSpaceOrCommentOrLinebreak }
+            ).map({ endOfLine(at: $0) })
+        {
+            // If we have an existing `endOfDeclaration` index from a parsing implementation like
+            // `parsePropertyDeclaration` or `parseFunctionDeclaration`, prefer that index.
+            if let existingEndOfDeclarationValue = endOfDeclaration {
+                endOfDeclaration = max(existingEndOfDeclarationValue, lastIndexBeforeNextDeclaration)
+            } else {
+                endOfDeclaration = lastIndexBeforeNextDeclaration
+            }
         }
 
         // Prefer keeping linebreaks at the end of a declaration's tokens,
@@ -3493,6 +3508,7 @@ extension _FormatRules {
         ["static", "class"],
         mutatingModifiers,
         ["prefix", "infix", "postfix"],
+        ["async"],
     ]
 
     /// Global swift functions

Sources/Rules/SinglePropertyPerLine.swift

@@ -22,6 +22,11 @@ public extension FormatRule {
                 return
             }
 
+            // Skip `async let` declarations
+            if formatter.modifiersForDeclaration(at: i, contains: "async") {
+                return
+            }
+
             // If this property is within a parenthesis scope, this is probably
             // within a switch case like `case (let foo, bar):`
             if let startOfScope = formatter.startOfScope(at: i),

Tests/ParsingHelpersTests.swift

@@ -824,6 +824,7 @@ class ParsingHelpersTests: XCTestCase {
             "static", "class",
             "borrowing", "consuming", "mutating", "nonmutating",
             "prefix", "infix", "postfix",
+            "async",
         ])
     }
 
@@ -848,6 +849,7 @@ class ParsingHelpersTests: XCTestCase {
             "convenience",
             "weak", "unowned", "unowned(safe)", "unowned(unsafe)",
             "prefix", "infix", "postfix",
+            "async",
         ])
     }
 

Tests/Rules/OrganizeDeclarationsTests.swift

@@ -4249,4 +4249,37 @@ class OrganizeDeclarationsTests: XCTestCase {
             exclude: [.blankLinesAtStartOfScope, .blankLinesAtEndOfScope]
         )
     }
+
+    func testOrganizesProtocolWithAsync() {
+        // Async variables are not allowed in protocols
+        let input = """
+        protocol Foo {
+            func foo() async
+            var bar: Bar { get }
+
+            func baaz()
+                async
+            var quux: Quux { get }
+        }
+        """
+
+        let output = """
+        protocol Foo {
+            var bar: Bar { get }
+
+            var quux: Quux { get }
+
+            func foo() async
+            func baaz()
+                async
+        }
+        """
+
+        testFormatting(
+            for: input, output,
+            rule: .organizeDeclarations,
+            options: FormatOptions(organizeTypes: ["protocol"]),
+            exclude: [.blankLinesAtStartOfScope, .blankLinesAtEndOfScope]
+        )
+    }
 }

Tests/Rules/SinglePropertyPerLineTests.swift

@@ -1112,4 +1112,12 @@ class SinglePropertyPerLineTests: XCTestCase {
         """
         testFormatting(for: input, rule: .singlePropertyPerLine)
     }
+
+    func testAsyncLetPreserved() {
+        let input = """
+        async let (one, two) = (performOne(), performTwo())
+        let (oneResult, twoResult) = await (one, two)
+        """
+        testFormatting(for: input, rule: .singlePropertyPerLine)
+    }
 }