Support async and throws on property/subscript getters.

Sources/SwiftFormatPrettyPrint/TokenStreamCreator.swift

@@ -441,6 +441,22 @@ fileprivate final class TokenStreamCreator: SyntaxVisitor {
 
   override func visit(_ node: AccessorDeclSyntax) -> SyntaxVisitorContinueKind {
     arrangeAttributeList(node.attributes)
+
+    if let asyncKeyword = node.asyncKeyword {
+      if node.throwsKeyword != nil {
+        before(asyncKeyword, tokens: .break, .open)
+      } else {
+        before(asyncKeyword, tokens: .break)
+      }
+    }
+
+    if let throwsKeyword = node.throwsKeyword {
+      before(node.throwsKeyword, tokens: .break)
+      if node.asyncKeyword != nil {
+        after(throwsKeyword, tokens: .close)
+      }
+    }
+
     arrangeBracesAndContents(of: node.body, contentsKeyPath: \.statements)
     return .visitChildren
   }

Tests/SwiftFormatPrettyPrintTests/AccessorTests.swift

@@ -295,4 +295,161 @@ final class AccessorTests: PrettyPrintTestCase {
 
     assertPrettyPrintEqual(input: input, expected: expected20, linelength: 20)
   }
+
+  func testPropertyEffectsWithBodyAfter() {
+    let input =
+      """
+      var x: T {
+        get async {
+          foo()
+          bar()
+        }
+      }
+      var x: T {
+        get throws {
+          foo()
+          bar()
+        }
+      }
+      var x: T {
+        get async throws {
+          foo()
+          bar()
+        }
+      }
+      """
+
+    assertPrettyPrintEqual(input: input, expected: input + "\n", linelength: 80)
+
+    let expected16 =
+      """
+      var x: T {
+        get async {
+          foo()
+          bar()
+        }
+      }
+      var x: T {
+        get throws {
+          foo()
+          bar()
+        }
+      }
+      var x: T {
+        get
+          async throws
+        {
+          foo()
+          bar()
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected16, linelength: 16)
+
+    let expected10 =
+      """
+      var x: T {
+        get
+          async
+        {
+          foo()
+          bar()
+        }
+      }
+      var x: T {
+        get
+          throws
+        {
+          foo()
+          bar()
+        }
+      }
+      var x: T {
+        get
+          async
+          throws
+        {
+          foo()
+          bar()
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected10, linelength: 10)
+  }
+
+  func testPropertyEffectsWithNoBodyAfter() {
+    let input =
+      """
+      protocol P {
+        var x: T { get async }
+        var x: T { get throws }
+        var x: T { get async throws }
+      }
+      """
+
+    assertPrettyPrintEqual(input: input, expected: input + "\n", linelength: 80)
+
+    let expected20 =
+      """
+      protocol P {
+        var x: T {
+          get async
+        }
+        var x: T {
+          get throws
+        }
+        var x: T {
+          get async throws
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected20, linelength: 20)
+
+    let expected18 =
+      """
+      protocol P {
+        var x: T {
+          get async
+        }
+        var x: T {
+          get throws
+        }
+        var x: T {
+          get
+            async throws
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected18, linelength: 18)
+
+    let expected12 =
+      """
+      protocol P {
+        var x: T {
+          get
+            async
+        }
+        var x: T {
+          get
+            throws
+        }
+        var x: T {
+          get
+            async
+            throws
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected12, linelength: 12)
+  }
 }

Tests/SwiftFormatPrettyPrintTests/SubscriptDeclTests.swift

@@ -497,4 +497,115 @@ final class SubscriptDeclTests: PrettyPrintTestCase {
       """
     assertPrettyPrintEqual(input: input, expected: wrapped, linelength: 28)
   }
+
+  func testAccessorEffectsWithBodyAfter() {
+    let input =
+      """
+      struct X {
+        subscript(i: Int) -> T {
+          get async throws {
+            foo()
+            bar()
+          }
+        }
+      }
+      """
+
+    assertPrettyPrintEqual(input: input, expected: input + "\n", linelength: 80)
+
+    let expected18 =
+      """
+      struct X {
+        subscript(
+          i: Int
+        ) -> T {
+          get
+            async throws
+          {
+            foo()
+            bar()
+          }
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected18, linelength: 18)
+
+    let expected12 =
+      """
+      struct X {
+        subscript(
+          i: Int
+        ) -> T {
+          get
+            async
+            throws
+          {
+            foo()
+            bar()
+          }
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected12, linelength: 12)
+  }
+
+  func testAccessorEffectsWithNoBodyAfter() {
+    let input =
+      """
+      protocol P {
+        subscript(i: Int) -> T { get async throws }
+      }
+      """
+
+    assertPrettyPrintEqual(input: input, expected: input + "\n", linelength: 80)
+
+    let expected20 =
+      """
+      protocol P {
+        subscript(i: Int)
+          -> T
+        {
+          get async throws
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected20, linelength: 20)
+
+    let expected18 =
+      """
+      protocol P {
+        subscript(
+          i: Int
+        ) -> T {
+          get
+            async throws
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected18, linelength: 18)
+
+    let expected16 =
+      """
+      protocol P {
+        subscript(
+          i: Int
+        ) -> T {
+          get
+            async
+            throws
+        }
+      }
+
+      """
+
+    assertPrettyPrintEqual(input: input, expected: expected16, linelength: 16)
+  }
 }