- let destinationUrl: URL
- let urlRouter: UrlRouter
- let screenIds: [String]
- let entityUuid: UUID

+ let destinationURL: URL
+ let urlRouter: URLRouter
+ let screenIDs: [String]
+ let entityUUID: UUID

- if true && true {
+ if true, true {

- guard true && true else {
+ guard true, true else {

- if functionReturnsBool() && true {
+ if functionReturnsBool(), true {

- if functionReturnsBool() && variable {
+ if functionReturnsBool(), variable {

- protocol Foo: class {}
+ protocol Foo: AnyObject {}

- @UIApplicationMain
+ @main
  class AppDelegate: UIResponder, UIApplicationDelegate {}

- assert(false)
+ assertionFailure()

- assert(false, "message", 2, 1)
+ assertionFailure("message", 2, 1)

- precondition(false, "message", 2, 1)
+ preconditionFailure("message", 2, 1)

  import A
  import B
  @testable import D
+
  class Foo {
    // foo
  }

  func handle(_ action: SpaceshipAction) {
      switch action {
      case .engageWarpDrive:
          navigationComputer.destination = targetedDestination
          await warpDrive.spinUp()
          warpDrive.activate()
+
      case let .scanPlanet(planet):
          scanner.target = planet
          scanner.scanAtmosphere()
          scanner.scanBiosphere()
          scanner.scanForArticialLife()
+
      case .handleIncomingEnergyBlast:
          await energyShields.prepare()
          energyShields.engage()
      }
  }

  func handle(_ action: SpaceshipAction) {
      switch action {
      case .engageWarpDrive:
          warpDrive.activate()

      case let .scanPlanet(planet):
          scanner.scanForArticialLife()

      case .handleIncomingEnergyBlast:
          energyShields.engage()
      }
  }

  func handle(_ action: SpaceshipAction) {
      switch action {
      case .engageWarpDrive:
          navigationComputer.destination = targetedDestination
          await warpDrive.spinUp()
          warpDrive.activate()
+
      case let .scanPlanet(planet):
          scanner.target = planet
          scanner.scanAtmosphere()
          scanner.scanBiosphere()
          scanner.scanForArticialLife()
+
      case .handleIncomingEnergyBlast:
          await energyShields.prepare()
          energyShields.engage()
      }
  }

  func handle(_ action: SpaceshipAction) {
      switch action {
      case .engageWarpDrive:
          warpDrive.activate()
+
      case let .scanPlanet(planet):
          scanner.scanForArticialLife()
+
      case .handleIncomingEnergyBlast:
          energyShields.engage()
      }
  }

    // Multiline guard
    guard let spicy = self.makeSpicy() else {
        return
    } 
-
    guard let yummy = self.makeYummy() else {
        return
    }
    guard let soap = self.clean() else {
        return
    }
+
    let doTheJob = nikekov()

    // Single-line guard
    guard let spicy = self.makeSpicy() else { return }
-
    guard let yummy = self.makeYummy() else { return }
    guard let soap = self.clean() else { return }
+
    let doTheJob = nikekov()

    // Multiline guard
    guard let spicy = self.makeSpicy() else {
        return
    }

    guard let yummy = self.makeYummy() else {
        return
    }
+
    guard let soap = self.clean() else {
        return
    }
+
    let doTheJob = nikekov()

    // Single-line guard
    guard let spicy = self.makeSpicy() else { return }

    guard let yummy = self.makeYummy() else { return }
+
    guard let soap = self.clean() else { return }
+
    let doTheJob = nikekov()

  func foo() {
    // foo
  }
  // MARK: bar
  func bar() {
    // bar
  }

  func foo() {
    // foo
  }
+
  // MARK: bar
+
  func bar() {
    // bar
  }

  func foo() {
    // foo
-
  }

  func foo() {
    // foo
  }

  array = [
    foo,
    bar,
    baz,
-
  ]

  array = [
    foo,
    bar,
    baz,
  ]

  struct Foo {
      let bar: Bar
+
  }

  func foo() {
-
    // foo
  }

  func foo() {
    // foo
  }

  array = [
-
    foo,
    bar,
    baz,
  ]

  array = [
    foo,
    bar,
    baz,
  ]

  struct Foo {
+
      let bar: Bar
  }

  [0, 1, 2]
      .map { $0 * 2 }
-
-
-
      .map { $0 * 3 }

  import A
-
  import B
  import C
-
-
  @testable import D
  import E

  func foo() {
    // foo
  }
  func bar() {
    // bar
  }
  var baz: Bool
  var quux: Int

  func foo() {
    // foo
  }
+
  func bar() {
    // bar
  }
+
  var baz: Bool
  var quux: Int

- /*
-  * foo
-  * bar
-  */

+ // foo
+ // bar

- /**
-  * foo
-  * bar
-  */

+ /// foo
+ /// bar

- if x
- {
    // foo
  }
- else
- {
    // bar
  }

+ if x {
    // foo
  }
+ else {
    // bar
  }

- let foo: String
- if condition {
+ let foo = if condition {
-     foo = "foo"
+     "foo"
  } else {
-     foo = "bar"
+     "bar"
  }

- let foo: String
- switch condition {
+ let foo = switch condition {
  case true:
-     foo = "foo"
+     "foo"
  case false:
-     foo = "bar"
+     "bar"
  }

  // With --condassignment always (disabled by default)
- switch condition {
+ foo.bar = switch condition {
  case true:
-     foo.bar = "baaz"
+     "baaz"
  case false:
-     foo.bar = "quux"
+     "quux"
  }

  func foo() {
    let x = "bar"
-

    print(x)
  }

  func foo() {
    let x = "bar"

    print(x)
  }

- let     foo = 5
+ let foo = 5

  func handle(_ action: SpaceshipAction) {
      switch action {
      case .engageWarpDrive:
          navigationComputer.destination = targetedDestination
          await warpDrive.spinUp()
          warpDrive.activate()

      case .enableArtificialGravity:
          artificialGravityEngine.enable(strength: .oneG)
+
      case let .scanPlanet(planet):
          scanner.target = planet
          scanner.scanAtmosphere()
          scanner.scanBiosphere()
          scanner.scanForArtificialLife()

      case .handleIncomingEnergyBlast:
          energyShields.engage()
      }
  }

  var name: PlanetType {
  switch self {
  case .mercury:
      "Mercury"
-
  case .venus:
      "Venus"
  case .earth:
      "Earth"
  case .mars:
      "Mars"
-
  case .jupiter:
      "Jupiter"
  case .saturn:
      "Saturn"
  case .uranus:
      "Uranus"
  case .neptune:
      "Neptune"
  }

- // A placeholder type used to demonstrate syntax rules
+ /// A placeholder type used to demonstrate syntax rules
  class Foo {
-     // This function doesn't really do anything
+     /// This function doesn't really do anything
      func bar() {
-         /// TODO: implement Foo.bar() algorithm
+         // TODO: implement Foo.bar() algorithm
      }
  }

+ /// Doc comment on this function declaration
  @MainActor
- /// Doc comment on this function declaration
  func foo() {}

  import Foo
  import Bar
- import Foo

  import B
  #if os(iOS)
    import A
-   import B
  #endif

  if x {
    // foo
- }
- else {
    // bar
  }

  if x {
    // foo
+ } else {
    // bar
  }

  do {
    // try foo
- }
- catch {
    // bar
  }

  do {
    // try foo
+ } catch {
    // bar
  }

  repeat {
    // foo
- }
- while {
    // bar
  }

  repeat {
    // foo
+ } while {
    // bar
  }

- func foo() {
-
- }

+ func foo() {}

- extension String {}
-
  extension String: Equatable {}

- class FeatureConstants {
+ enum FeatureConstants {
      static let foo = "foo"
      static let bar = "bar"
  }

- struct ScreenNameEnvironmentKey: EnvironmentKey {
-   static var defaultValue: Identifier? {
-      .init("undefined") 
-     }
-   }

   extension EnvironmentValues {
-    var screenName: Identifier? {
-      get { self[ScreenNameEnvironmentKey.self] }
-      set { self[ScreenNameEnvironmentKey.self] = newValue }
-    }
+    @Entry var screenName: Identifier? = .init("undefined")
   }

- extension Foo {
-     public func bar() {}
-     public func baz() {}
  }

+ public extension Foo {
+     func bar() {}
+     func baz() {}
  }

- public extension Foo {
-     func bar() {}
-     func baz() {}
-     internal func quux() {}
  }

+ extension Foo {
+     public func bar() {}
+     public func baz() {}
+     func quux() {}
  }

- // SomeFile.swift

+ //
+ //  SomeFile.swift
+ //  Copyright © 2023 Tim Apple.
+ //

- // Created {created}
+ // Created 2023-08-10

- // Created {created}
+ // Created 10/08/2023

- // Created {created}
+ // Created 08/10/2023

- // Created {created}
+ // Created 2023.08.10.11.00

- // Created {created}
+ // Created 2023-08-10 11:00 GMT

- // Created 2023-08-10 11:00 GMT
+ // Created 2023-08-10 23:00 GMT+12:00

  // --filemacro #file
- func foo(file: StaticString = #fileID) { ... }
+ func foo(file: StaticString = #file) { ... }

  // --filemacro #fileID
- func foo(file: StaticString = #file) { ... }
+ func foo(file: StaticString = #fileID) { ... }

- extension Array where Element == Foo {}
- extension Optional where Wrapped == Foo {}
- extension Dictionary where Key == Foo, Value == Bar {}
- extension Collection where Element == Foo {}
+ extension Array<Foo> {}
+ extension Optional<Foo> {}
+ extension Dictionary<Key, Value> {}
+ extension Collection<Foo> {}

  // With `typeSugar` also enabled:
- extension Array where Element == Foo {}
- extension Optional where Wrapped == Foo {}
- extension Dictionary where Key == Foo, Value == Bar {}
+ extension [Foo] {}
+ extension Foo? {}
+ extension [Key: Value] {}

  // Also supports user-defined types!
- extension LinkedList where Element == Foo {}
- extension Reducer where
-     State == FooState,
-     Action == FooAction,
-     Environment == FooEnvironment {}
+ extension LinkedList<Foo> {}
+ extension Reducer<FooState, FooAction, FooEnvironment> {}

- //  Foo.swift
+ //  Bar.swift
  //  SwiftFormat
  //
  //  Created by Nick Lockwood on 5/3/23.

  struct Bar {}

- greet(await forename, await surname)
+ await greet(forename, surname)

- let foo = String(try await getFoo())
+ let foo = await String(try getFoo())

- (let foo, let bar) = baz()
+ let (foo, bar) = baz()

- if case .foo(let bar, let baz) = quux {
    // inner foo
  }

+ if case let .foo(bar, baz) = quux {
    // inner foo
  }

- foo(try bar(), try baz())
+ try foo(bar(), baz())

- let foo = String(try await getFoo())
+ let foo = try String(await getFoo())

  if x {
-     // foo
  } else {
-     // bar
-       }

  if x {
+   // foo
  } else {
+   // bar
+ }

  let array = [
    foo,
-     bar,
-       baz
-   ]

  let array = [
    foo,
+   bar,
+   baz
+ ]

  switch foo {
-   case bar: break
-   case baz: break
  }

  switch foo {
+ case bar: break
+ case baz: break
  }

+ @available(*, unavailable)
  required init?(coder aDecoder: NSCoder) {
    fatalError("init(coder:) has not been implemented")
  }

- if foo.count == 0 {
+ if foo.isEmpty {

- if foo.count > 0 {
+ if !foo.isEmpty {

- if foo?.count == 0 {
+ if foo?.isEmpty == true {

- guard let foo = maybeFoo // first
-     , let bar = maybeBar else { ... }

+ guard let foo = maybeFoo, // first
+      let bar = maybeBar else { ... }

  struct Foo {↩
      let bar: Bar↩
- }
+ }↩
+

+ // MARK: - FooViewController
+
  final class FooViewController: UIViewController { }

+ // MARK: UICollectionViewDelegate
+
  extension FooViewController: UICollectionViewDelegate { }

+ // MARK: - String + FooProtocol
+
  extension String: FooProtocol { }

- lazy public weak private(set) var foo: UIView?
+ public private(set) lazy weak var foo: UIView?

- final public override func foo()
+ override public final func foo()

- convenience private init()
+ private convenience init()

- @MainActor
- public
- private(set)
- var foo: Foo

+ @MainActor
+ public private(set) var foo: Foo

- nonisolated
- func bar() {}

+ nonisolated func bar() {}

- borrowing func foo(_ bar: consuming Bar) { ... }
+ func foo(_ bar: Bar) { ... }

    import Testing

    struct MyFeatureTests {
-       @Test func doSomething() {
+       @Test func doSomething() throws {
-           try! MyFeature().doSomething()
+           try MyFeature().doSomething()
      }
    }

    import XCTeset

    class MyFeatureTests: XCTestCase {
-       func test_doSomething() {
+       func test_doSomething() throws {
-           try! MyFeature().doSomething()
+           try MyFeature().doSomething()
      }
    }

    import Testing

    struct MyFeatureTests {
-       @Test func myFeature() {
-           let myValue = foo.bar!.value as! Value
-           let otherValue = (foo! as! Other).bar
-           otherValue.manager!.prepare()
-           #expect(myValue!.property! == other)
+       @Test func myFeature() throws {
+           let myValue = try #require(foo.bar?.value as? Value)
+           let otherValue = try #require((foo as? Other)?.bar)
+           otherValue.manager?.prepare()
+           #expect(myValue?.property == other)
      }
    }

    import XCTest

    class MyFeatureTests: XCTestCase {
-       func testMyFeature() {
-           let myValue = foo.bar!.value as! Value
-           let otherValue = (foo! as! Other).bar
-           XCTAssertEqual(myValue!.property!, "foo")
+       func testMyFeature() throws {
+           let myValue = try XCTUnwrap(foo.bar?.value as? Value)
+           let otherValue = try XCTUnwrap((foo as? Other)?.bar)
+           XCTAssertEqual(myValue?.property, otherValue)
      }
    }

  import XCTest

  final class SomeTestCase: XCTestCase {
-     func test_something() {
+     func test_something() throws {
-         guard let value = optionalValue, value.matchesCondition else {
-             XCTFail()
-             return
-         }
+         let value = try XCTUnwrap(optionalValue)
+         XCTAssert(value.matchesCondition)
      }
  }

  import Testing

  struct SomeTests {
      @Test
      func something() throws {
-         guard let value = optionalValue, value.matchesCondition else {
-             return
-         }
+         let value = try #require(optionalValue)
+         #expect(value.matchesCondition)
      }
  }

- let color = 0xFF77A5
+ let color = 0xff77a5

- let big = 123456.123
+ let big = 123_456.123

- func handle<T: Fooable>(_ value: T) {
+ func handle(_ value: some Fooable) {
      print(value)
  }

- func handle<T>(_ value: T) where T: Fooable, T: Barable {
+ func handle(_ value: some Fooable & Barable) {
      print(value)
  }

- func handle<T: Collection>(_ value: T) where T.Element == Foo {
+ func handle(_ value: some Collection<Foo>) {
      print(value)
  }

  // With `--some-any enabled` (the default)
- func handle<T>(_ value: T) {
+ func handle(_ value: some Any) {
      print(value)
  }

  public class Foo {
-     public func c() -> String {}
-
-     public let a: Int = 1
-     private let g: Int = 2
-     let e: Int = 2
-     public let b: Int = 3
-
-     public func d() {}
-     func f() {}
-     init() {}
-     deinit() {}
  }

  public class Foo {
+
+     // MARK: Lifecycle
+
+     init() {}
+     deinit() {}
+
+     // MARK: Public
+
+     public let a: Int = 1
+     public let b: Int = 3
+
+     public func c() -> String {}
+     public func d() {}
+
+     // MARK: Internal
+
+     let e: Int = 2
+
+     func f() {}
+
+     // MARK: Private
+
+     private let g: Int = 2
+
  }

  public class Foo {
-     public func c() -> String {}
-
-     public let a: Int = 1
-     private let g: Int = 2
-     let e: Int = 2
-     public let b: Int = 3
-
-     public func d() {}
-     func f() {}
-     init() {}
-     deinit() {}
  }

  public class Foo {
+
+     // MARK: Properties
+
+     public let a: Int = 1
+     public let b: Int = 3
+
+     let e: Int = 2
+
+     private let g: Int = 2
+
+     // MARK: Lifecycle
+
+     init() {}
+     deinit() {}
+
+     // MARK: Functions
+
+     public func c() -> String {}
+     public func d() {}
+
  }

- planets.filter { !$0.moons.isEmpty }.count
+ planets.count(where: { !$0.moons.isEmpty })

- planets.filter { planet in
-     planet.moons.filter { moon in
-         moon.hasAtmosphere
-     }.count > 1
- }.count
+ planets.count(where: { planet in
+     planet.moons.count(where: { moon in
+         moon.hasAtmosphere
+     }) > 1
+ })

- if !flag {
+ if flag == false {

- guard !array.isEmpty else { return }
+ guard array.isEmpty == false else { return }

- class Foo {}
+ final class Foo {}

- public class Bar {}
+ public final class Bar {}

  // Preserved classes:
  open class Baz {}

  class BaseClass {}

  class MyClass {} // Subclassed in this file
  class MySubclass: MyClass {}

  /// Base class to be subclassed by other features
  class MyCustomizationPoint {}

  let strings = ["foo", "bar", "baaz"]
- strings.forEach { placeholder in
+ for placeholder in strings {
      print(placeholder)
  }

  // Supports anonymous closures
- strings.forEach {
+ for string in strings {
-     print($0)
+     print(string)
  }

- foo.item().bar[2].baazValues(option: true).forEach {
+ for baazValue in foo.item().bar[2].baazValues(option: true) {
-     print($0)
+     print(baazValue)
  }

  // Doesn't affect long multiline functional chains
  placeholderStrings
      .filter { $0.style == .fooBar }
      .map { $0.uppercased() }
      .forEach { print($0) }

- let barArray = fooArray.map { $0.bar }
+ let barArray = fooArray.map(\.bar)

- let barArray = fooArray.compactMap { $0.optionalBar }
+ let barArray = fooArray.compactMap(\.optionalBar)

- str.replacingOccurrences(of: "foo", with: "bar")
+ str.replacing("foo", with: "bar")

  @testable import MyFeatureLib
- import XCTest
+ import Testing
+ import Foundation

- final class MyFeatureTests: XCTestCase {
-     func testMyFeatureHasNoBugs() {
-         let myFeature = MyFeature()
-         myFeature.runAction()
-         XCTAssertFalse(myFeature.hasBugs, "My feature has no bugs")
-         XCTAssertEqual(myFeature.crashes.count, 0, "My feature doesn't crash")
-         XCTAssertNil(myFeature.crashReport)
-     }
- }
+ final class MyFeatureTests { 
+     @Test func myFeatureHasNoBugs() {
+         let myFeature = MyFeature()
+         myFeature.runAction()
+         #expect(!myFeature.hasBugs, "My feature has no bugs")
+         #expect(myFeature.crashes.isEmpty, "My feature doesn't crash")
+         #expect(myFeature.crashReport == nil)
+     }
+ }

- final class MyFeatureTests: XCTestCase {
-     var myFeature: MyFeature!
- 
-     override func setUp() async throws {
-         myFeature = try await MyFeature()
-     }
- 
-     override func tearDown() {
-         myFeature = nil
-     }
- 
-     func testMyFeatureWorks() {
-         myFeature.runAction()
-         XCTAssertTrue(myFeature.worksProperly)
-         XCTAssertEqual(myFeature.screens.count, 8)
-     }
- }
+ final class MyFeatureTests {
+     var myFeature: MyFeature!
+ 
+     init() async throws {
+         myFeature = try await MyFeature()
+     }
+ 
+     deinit {
+         myFeature = nil
+     }
+ 
+     @Test func myFeatureWorks() {
+         myFeature.runAction()
+         #expect(myFeature.worksProperly)
+         #expect(myFeature.screens.count == 8)
+     }
+ }

- @State var anInt: Int
+ @State private var anInt: Int

- @StateObject var myInstance: MyObject
+ @StateObject private var myInstace: MyObject

  // with --propertytypes inferred
- let view: UIView = .init()
+ let view = UIView()

- let color: Color = .red
+ let color = Color.red

- let array: [Int] = []
+ let array = [Int]()

- let set: Set<Int> = []
+ let set = Set<Int>()

- let dict: [String: Int] = [:]
+ let dict = [String: Int]()

  // with --propertytypes explicit
- let view = UIView()
+ let view: UIView = .init()

- let color = Color.red
+ let color: Color = .red

- let array = [Int]()
+ let array: [Int] = []

- let set = Set<Int>()
+ let set: Set<Int> = []

- let dict = [String: Int]()
+ let dict: [String: Int] = [:]

  // with --propertytypes infer-locals-only
  class Foo {
-     let view: UIView = UIView()
+     let view: UIView = .init()

      func method() {
-         let view: UIView = UIView()
+         let view = UIView()
      }
  }

  // with --inferredtypes always:
- let foo: Foo =
+ let foo =
    if condition {
-     .init(bar)
+     Foo(bar)
    } else {
-     .init(baaz)
+     Foo(baaz)
    }

  // With --redundant-async tests-only (default)
  import Testing

- @Test func myFeature() async {
+ @Test func myFeature() {
      #expect(foo == 1)
  }

  import XCTest

  class TestCase: XCTestCase {
-     func testMyFeature() async {
+     func testMyFeature() {
          XCTAssertEqual(foo, 1)
      }
  }

  // With --redundant-async always
- func myNonAsyncMethod() async -> Int {
+ func myNonAsyncMethod() -> Int {
      return 0
  }

  // Possibly elsewhere in codebase:
  let value = await myNonAsyncMethod()
+             `- warning: no 'async' operations occur within 'await' expression

- let `infix` = bar
+ let infix = bar

- func foo(with `default`: Int) {}
+ func foo(with default: Int) {}

  switch foo {
    case bar:
        print("bar")
-       break
    default:
        print("default")
-       break
  }

- let foo = { Foo() }()
+ let foo = Foo()

- lazy var bar = {
-     Bar(baaz: baaz,
-         quux: quux)
- }()
+ lazy var bar = Bar(baaz: baaz,
+                    quux: quux)

  var body: some View {
      if condition {
          Text("Hello")
-     } else {
-         EmptyView()
      }
  }

  struct Foo: Equatable {
      let bar: Bar
      let baaz: Baaz

-     static func ==(lhs: Foo, rhs: Foo) -> Bool {
-         lhs.bar == rhs.bar 
-             && lhs.baaz == rhs.baaz
-     }
  }

  class Bar: Equatable {
      let baaz: Baaz

      static func ==(lhs: Bar, rhs: Bar) -> Bool {
          lhs.baaz == rhs.baaz
      }
  }

  // --equatable-macro @Equatable,MyMacroLib
  import FooLib
+ import MyMacroLib

+ @Equatable
+ class Bar {
- class Bar: Equatable {
      let baaz: Baaz

-     static func ==(lhs: Bar, rhs: Bar) -> Bool {
-         lhs.baaz == rhs.baaz
-     }
  }

  public extension URL {
-   public func queryParameter(_ name: String) -> String { ... }
  }

  public extension URL {
+   func queryParameter(_ name: String) -> String { ... }
  }

-  fileprivate let someConstant = "someConstant"
+  private let someConstant = "someConstant"

  class Foo {
-   fileprivate var foo = "foo"
+   private var foo = "foo"
  }

  extension Foo {
    func bar() {
      print(self.foo)
    }
  }

  var foo: Int {
-   get {
-     return 5
-   }
  }

  var foo: Int {
+   return 5
  }

- String.init("text")
+ String("text")

- internal class Foo {
+ class Foo {
-     internal let bar: String
+     let bar: String

-     internal func baaz() {}
+     func baaz() {}

-     internal init() {
+     init() {
          bar = "bar"
      }
  }

- let _ = foo()
+ _ = foo()

- do { ... } catch let error { log(error) }
+ do { ... } catch { log(error) }

  struct User {
      var name: String
      var age: Int

-     init(name: String, age: Int) {
-         self.name = name
-         self.age = age
-     }
  }

  struct MyView<Content: View>: View {
+     @ViewBuilder let content: Content
-     let content: Content
-
-     init(@ViewBuilder content: () -> Content) {
-         self.content = content()
-     }

      var body: some View {
          content
      }
  }

  struct ProfileView: View {
-     init(user: User, settings: Settings) {
-         self.user = user
-         self.settings = settings
-     }
-
-     private let user: User
-     private let settings: Settings
+     let user: User
+     let settings: Settings

      var body: some View { ... }
  }

- var foo: Int? = nil
+ var foo: Int?

  // doesn't apply to `let` properties
  let foo: Int? = nil

  // doesn't affect non-nil initialization
  var foo: Int? = 0

- var foo: Int?
+ var foo: Int? = nil

- @objc @IBOutlet var label: UILabel!
+ @IBOutlet var label: UILabel!

- @IBAction @objc func goBack() {}
+ @IBAction func goBack() {}

- @objc @NSManaged private var foo: String?
+ @NSManaged private var foo: String?

- if let foo = foo {
+ if let foo {
      print(foo)
  }

- guard let self = self else {
+ guard let self else {
      return
  }

- if (foo == true) {}
+ if foo == true {}

- while (i < bar.count) {}
+ while i < bar.count {}

- queue.async() { ... }
+ queue.async { ... }

- let foo: Int = ({ ... })()
+ let foo: Int = { ... }()

- @Test()
+ @Test

- if case .foo(_, _) = bar {}
+ if case .foo = bar {}

- let (_, _) = bar
+ let _ = bar

  struct Foo {
-     public let bar: Bar
+     let bar: Bar
-     public func baz() {}
+     func baz() {}
  }

  extension Foo {
-     public func quux() {}
+     func quux() {}
  }

  enum Foo: String {
-   case bar = "bar"
    case baz = "quux"
  }

  enum Foo: String {
+   case bar
    case baz = "quux"
  }

- array.filter { return $0.foo == bar }
+ array.filter { $0.foo == bar }

  // Swift 5.1+ (SE-0255)
  var foo: String {
-     return "foo"
+     "foo"
  }

  // Swift 5.9+ (SE-0380) and with conditionalAssignment rule enabled
  func foo(_ condition: Bool) -> String {
      if condition {
-         return "foo"
+         "foo"
      } else {
-         return "bar"
+         "bar"
      }
  }

  func foobar(foo: Int, bar: Int) {
    self.foo = foo
    self.bar = bar
-   self.baz = 42
  }

  func foobar(foo: Int, bar: Int) {
    self.foo = foo
    self.bar = bar
+   baz = 42
  }

  init(foo: Int, bar: Int) {
    self.foo = foo
    self.bar = bar
-   baz = 42
  }

  init(foo: Int, bar: Int) {
    self.foo = foo
    self.bar = bar
+   self.baz = 42
  }

- struct CacheEntry: Sendable {
+ struct CacheEntry {
      let id: String
  }

- fileprivate enum ParsingState: Sendable {
+ fileprivate enum ParsingState {
      case idle
      case running
  }

  enum Foo {
      static let bar = Bar()

      static func baaz() -> Bar {
-         Self.bar()
+         bar()
      }
  }

  import Testing

- @Suite
  struct MyFeatureTests {
      @Test func myFeature() {
          #expect(true)
      }
  }

- @Suite()
  struct OtherTests {
      @Test func otherFeature() {
          #expect(true)
      }
  }

  // Not redundant - @Suite has arguments
  @Suite(.serialized)
  struct SerializedTests {
      @Test func feature() {
          #expect(true)
      }
  }

  // With --redundant-throws tests-only (default)
  import Testing

- @Test func myFeature() throws {
+ @Test func myFeature() throws {
      #expect(foo == 1)
  }

  import XCTest

  class TestCase: XCTestCase {
-     func testMyFeature() throws {
+     func testMyFeature() {
          XCTAssertEqual(foo, 1)
      }
  }

  // With --redundant-throws always
- func myNonThrowingMethod() throws -> Int {
+ func myNonThrowingMethod() -> Int {
      return 0
  }

  // Possibly elsewhere in codebase:
  let value = try myNonThrowingMethod()
+             `- warning: no calls to throwing functions occur within 'try' expression

  // with --propertytypes inferred
- let view: UIView = UIView()
+ let view = UIView()

  // with --propertytypes explicit
- let view: UIView = UIView()
+ let view: UIView = .init()

  // with --propertytypes infer-locals-only
  class Foo {
-     let view: UIView = UIView()
+     let view: UIView = .init()

      func method() {
-         let view: UIView = UIView()
+         let view = UIView()
      }
  }

  // Swift 5.9+, with --propertytypes inferred (SE-0380)
- let foo: Foo = if condition {
+ let foo = if condition {
      Foo("foo")
  } else {
      Foo("bar")
  }

  // Swift 5.9+, with --propertytypes explicit (SE-0380)
  let foo: Foo = if condition {
-     Foo("foo")
+     .init("foo")
  } else {
-     Foo("bar")
+     .init("foo")
  }

- func foo() throws(Never) -> Int {
+ func foo() -> Int {
      return 0
  }

- func foo() throws(any Error) -> Int {
+ func foo() throws -> Int {
      throw MyError.foo
  }

  func foo() -> Foo {
-   let foo = Foo()
-   return foo
+   return Foo()
  }

  struct MyView: View {
-   @ViewBuilder
    var body: some View {
      Text("foo")
      Text("bar")
    }

-   @ViewBuilder
    var helper: some View {
      VStack {
        Text("baaz")
        Text("quux")
      }
    }

    // Not redundant - multiple top-level views
    @ViewBuilder
    var helper2: some View {
      Text("foo")
      Text("bar")
    }
  }

- func foo() -> Void {
    // returns nothing
  }

+ func foo() {
    // returns nothing
  }

- let foo = 5;
+ let foo = 5

- let foo = 5; let bar = 6
+ let foo = 5
+ let bar = 6

  // semicolon is not removed if it would affect the behavior of the code
  return;
  goto(fail)

- struct Foo<T, U> where T: Hashable, U: Codable {}
+ struct Foo<T: Hashable, U: Codable> {}

- class Bar<Element> where Element: Equatable {
+ class Bar<Element: Equatable> {
      // ...
  }

- enum Result<Value, Error> where Value: Decodable, Error: Swift.Error {}
+ enum Result<Value: Decodable, Error: Swift.Error> {}

- func process<T>(_ value: T) where T: Codable {}
+ func process<T: Codable>(_ value: T) {}

- let a, b, c: Int
+ let a: Int
+ let b: Int
+ let c: Int

- public var foo = 10, bar = false
+ public var foo = 10
+ public var bar = false

- var (foo, bar) = ("foo", "bar")
+ var foo = "foo"
+ var bar = "bar"

- private let (foo, bar): (Int, Bool) = (10, false)
+ private let foo: Int = 10
+ private let bar: Bool = false

  // Preserved:
  let (foo, bar) = methodCallWithPossibleSideEffects()

  // swiftformat:sort
  enum FeatureFlags {
-     case upsellB
-     case fooFeature
-     case barFeature
-     case upsellA(
-         fooConfiguration: Foo,
-         barConfiguration: Bar)
+     case barFeature
+     case fooFeature
+     case upsellA(
+         fooConfiguration: Foo,
+         barConfiguration: Bar)
+     case upsellB
  }

  /// With --sortedpatterns Feature
  enum FeatureFlags {
-     case upsellB
-     case fooFeature
-     case barFeature
-     case upsellA(
-         fooConfiguration: Foo,
-         barConfiguration: Bar)
+     case barFeature
+     case fooFeature
+     case upsellA(
+         fooConfiguration: Foo,
+         barConfiguration: Bar)
+     case upsellB
  }

  enum FeatureFlags {
      // swiftformat:sort:begin
-     case upsellB
-     case fooFeature
-     case barFeature
-     case upsellA(
-         fooConfiguration: Foo,
-         barConfiguration: Bar)
+     case barFeature
+     case fooFeature
+     case upsellA(
+         fooConfiguration: Foo,
+         barConfiguration: Bar)
+     case upsellB
      // swiftformat:sort:end

      var anUnsortedProperty: Foo {
          Foo()
      }
  }

- import Foo
- import Bar
+ import Bar
+ import Foo

- import B
- import A
- #if os(iOS)
-   import Foo-iOS
-   import Bar-iOS
- #endif
+ import A
+ import B
+ #if os(iOS)
+   import Bar-iOS
+   import Foo-iOS
+ #endif

  switch self {
- case .b, .a, .c, .e, .d:
+ case .a, .b, .c, .d, .e:
      return nil
  }

- typealias Placeholders = Foo & Bar & Baaz & Quux
+ typealias Placeholders = Baaz & Bar & Foo & Quux

  typealias Dependencies
-     = FooProviding
+     = BaazProviding
      & BarProviding
-     & BaazProviding
+     & FooProviding
      & QuuxProviding

- foo.filter{ return true }.map{ $0 }
+ foo.filter { return true }.map { $0 }

- foo( {} )
+ foo({})

- foo as[String]
+ foo as [String]

- foo = bar [5]
+ foo = bar[5]

- let a = 5// assignment
+ let a = 5 // assignment

- func foo()
+ func foo() { /* ... */ }

- Foo <Bar> ()
+ Foo<Bar>()

- foo . bar()
+ foo.bar()

- a+b+c
+ a + b + c

- func ==(lhs: Int, rhs: Int) -> Bool
+ func == (lhs: Int, rhs: Int) -> Bool

- init (foo)
+ init(foo)

- switch(x){
+ switch (x) {

- foo.filter {return true}
+ foo.filter { return true }

- [ 1, 2, 3 ]
+ [1, 2, 3]

- let a = 5 //assignment
+ let a = 5 // assignment

- func foo() { /*...*/ }
+ func foo() { /* ... */ }

- Foo< Bar, Baz >
+ Foo<Bar, Baz>

- ( a, b)
+ (a, b)

- @IBOutlet weak var label: UILabel!
+ @IBOutlet var label: UILabel!

- guard let `self` = self else { return }
+ guard let self = self else { return }

  import Testing

  struct MyFeatureTests {
-     @Test func testMyFeatureHasNoBugs() {
+     @Test func `my feature has no bugs`() {
          let myFeature = MyFeature()
          myFeature.runAction()
          #expect(!myFeature.hasBugs, "My feature has no bugs")
          #expect(myFeature.crashes.isEmpty, "My feature doesn't crash")
          #expect(myFeature.crashReport == nil)
      }

-     @Test func `test feature works as expected`(_ feature: Feature) {
+     @Test func `feature works as expected`(_ feature: Feature) {
        let myFeature = MyFeature()
        myFeature.run(feature)
        #expect(myFeature.worksAsExpected)
    }
  }

  import XCTest

  final class MyTests: XCTestCase {
-     public func testExample() {
+     func testExample() {
          XCTAssertTrue(true)
      }

-     func helperMethod() {
+     private func helperMethod() {
          // helper code
      }
  }

  import Testing

  struct MyFeatureTests {
-     @Test public func featureWorks() {
+     @Test func featureWorks() {
          #expect(true)
      }

-     func helperMethod() {
+     private func helperMethod() {
          // helper code
      }
  }

- /* TODO fix this properly */
+ /* TODO: fix this properly */

- // MARK - UIScrollViewDelegate
+ // MARK: - UIScrollViewDelegate

- DispatchQueue.main.async(execute: { ... })
+ DispatchQueue.main.async {

- let foo = bar.map({ ... }).joined()
+ let foo = bar.map { ... }.joined()

- withAnimation(.spring, {
-   isVisible = true
- }, completion: {
-   handleCompletion()
- })
+ withAnimation(.spring) {
+   isVisible = true
+ } completion: {
+   handleCompletion()
+ }

  let array = [
    foo,
    bar,
-   baz
+   baz,
  ]

  func foo(
      bar: Int,
-     baaz: Int
+     baaz: Int,
  ) {}

  foo(
      bar: 1,
-     baaz: 2
+     baaz: 2,
  )

  struct Foo<
      Bar,
      Baaz,
-     Quux
+     Quux,
  > {}

  let foo = [
-     bar,
+     bar
  ]

  foo(
-     bar,
+     bar
  )

- let foo: Foo␣
+ let foo: Foo
- ␣␣␣␣
+
- func bar() {␣␣
+ func bar() {
  ␣␣␣␣print("foo")
  }

- var foo: Optional<String>
+ var foo: String?

- var foo: Array<String>
+ var foo: [String]

- var foo: Dictionary<String, Int>
+ var foo: [String: Int]

struct Foo {
    var bar: Optional<String>
}

- func foo(bar: Int, baz: String) {
    print("Hello \(baz)")
  }

+ func foo(bar _: Int, baz: String) {
    print("Hello \(baz)")
  }

- func foo(_ bar: Int) {
    ...
  }

+ func foo(_: Int) {
    ...
  }

- request { response, data in
    self.data += data
  }

+ request { _, data in
    self.data += data
  }

- for (key, value) in dictionary {
    print(key)
  }

+ for (key, _) in dictionary {
    print(key)
  }

  struct Foo {
-     fileprivate var foo = "foo"
-     fileprivate var baz = "baz"
      var bar = "bar"
  }

- let url = URL(string: "https://example.com")!
+ import URLFoundation
+ let url = #URL("https://example.com")

- return URL(string: "https://api.example.com/users")!
+ import URLFoundation
+ return #URL("https://api.example.com/users")

  import XCTest

  final class MyTests: XCTestCase {
-     func myFeatureWorksCorrectly() {
+     func testMyFeatureWorksCorrectly() {
          XCTAssertTrue(myFeature.worksCorrectly)
      }
  }

  import Testing

  struct MyFeatureTests {
-     func testMyFeatureWorksCorrectly() {
+     @Test func myFeatureWorksCorrectly() {
          #expect(myFeature.worksCorrectly)
      }

-     func myFeatureHasNoBugs() {
+     @Test func myFeatureHasNoBugs() {
          #expect(myFeature.hasNoBugs)
      }
  }

- let foo: () -> ()
+ let foo: () -> Void

- let bar: Void -> Void
+ let bar: () -> Void

- let baz: (Void) -> Void
+ let baz: () -> Void

- func quux() -> (Void)
+ func quux() -> Void

- callback = { _ in Void() }
+ callback = { _ in () }

- foo(bar: Int,
-     baz: String)

+ foo(
+   bar: Int,
+   baz: String
+ )

- class Foo<Bar,
-           Baz>

+ class Foo<
+   Bar,
+   Baz
+ >

- func foo(
-   bar: Int,
-   baz: String
- ) {
    ...
  }

+ func foo(bar: Int,
+          baz: String)
+ {
    ...
  }

- let foo = [bar,
             baz,
-            quuz]

+ let foo = [
+   bar,
    baz,
+   quuz
+ ]

- @objc func foo() {}

+ @objc
+ func foo() { }

- @objc
- func foo() { }

+ @objc func foo() {}

- @objc class Foo {}

+ @objc
+ class Foo { }

- @objc
- enum Foo { }

+ @objc enum Foo {}

- case .foo: return bar
+ case .foo:
+     return bar

- guard let foo = bar else { return baz }
+ guard let foo = bar else {
+     return baz
+ }

- if foo { return bar }
+ if foo {
+    return bar
+ }

  enum Foo {
-   case bar, baz
  }

  enum Foo {
+   case bar
+   case baz
  }

- func foo() { print("bar") }
+ func foo() {
+     print("bar")
+ }

- init() { self.value = 0 }
+ init() {
+     self.value = 0
+ }

- subscript(index: Int) -> Int { array[index] }
+ subscript(index: Int) -> Int {
+     array[index]
+ }

- for foo in array { print(foo) }
+ for foo in array {
+     print(foo)
+ }

- while let foo = bar.next() { print(foo) }
+ while let foo = bar.next() {
+     print(foo)
+ }

- let planetLocation = if let star = planet.star {
-     "The \(star.name) system"
- } else {
-     "Rogue planet"
- }
+ let planetLocation =
+     if let star = planet.star {
+         "The \(star.name) system"
+     } else {
+         "Rogue planet"
+     }

  let evenSquaresSum = [20, 17, 35, 4]
-   .filter { $0 % 2 == 0 }.map { $0 * $0 }
    .reduce(0, +)

  let evenSquaresSum = [20, 17, 35, 4]
+   .filter { $0 % 2 == 0 }
+   .map { $0 * $0 }
    .reduce(0, +)

  if foo,
-   bar {
    // ...
  }

  if foo,
+   bar
+ {
    // ...
  }

  guard foo,
-   bar else {
    // ...
  }

  guard foo,
+   bar else
+ {
    // ...
  }

  func foo(
    bar: Int,
-   baz: Int) {
    // ...
  }

  func foo(
    bar: Int,
+   baz: Int)
+ {
    // ...
  }

  class Foo: NSObject,
-   BarProtocol {
    // ...
  }

  class Foo: NSObject,
+   BarProtocol
+ {
    // ...
  }

- var bar: String { "bar" }
+ var bar: String {
+     "bar"
+ }

- var foo: Int { didSet { bar() } }
+ var foo: Int {
+     didSet { bar() }
+ }

  switch foo {
-   case .bar, .baz:
      break
  }

  switch foo {
+   case .foo,
+        .bar:
      break
  }

- if 5 == foo,
+ if foo == 5,
-    nil != bar,
+    bar != nil,
-    .default == baaz,
+    baaz == .default,
  { ... }