Add rule to infer property types from the right-hand-side value rather than writing the type explicitly on the left-hand side

Package.swift

@@ -42,8 +42,8 @@ let package = Package(
 
     .binaryTarget(
       name: "SwiftFormat",
-      url: "https://github.com/calda/SwiftFormat/releases/download/0.54-beta-4/SwiftFormat.artifactbundle.zip",
-      checksum: "65335d1e059714d570ee6dbe76d3738fbae3a404dafb109371a6a55670b5bcd7"),
+      url: "https://github.com/calda/SwiftFormat/releases/download/0.54-beta-5/SwiftFormat.artifactbundle.zip",
+      checksum: "7447986db45a51164d23672c07f971406a4c0589b0c423fcb85e95ed8f8e7e48"),
 
     .binaryTarget(
       name: "SwiftLintBinary",

README.md

@@ -333,25 +333,106 @@ _You can enable the following settings in Xcode by running [this script](resourc
 
   ```swift
   // WRONG
-  let host: Host = Host()
+  let sun: Star = Star(mass: 1.989e30)
+  let earth: Planet = Planet.earth
 
   // RIGHT
-  let host = Host()
+  let sun = Star(mass: 1.989e30)
+  let earth = Planet.earth
+
+  // WRONG: Most literals provide a default type that can be inferred.
+  let enableGravity: Bool = true
+  let numberOfPlanets: Int = 8
+  let sunMass: Double = 1.989e30
+
+  // RIGHT
+  let enableGravity = true
+  let numberOfPlanets = 8
+  let sunMass = 1.989e30
+
+  // WRONG: Types can be inferred from if/switch expressions as well if each branch has the same explicit type.
+  let smallestPlanet: Planet =
+    if treatPlutoAsPlanet {
+      Planet.pluto
+    } else {
+      Planet.mercury
+    }
+
+  // RIGHT
+  let smallestPlanet =
+    if treatPlutoAsPlanet {
+      Planet.pluto
+    } else {
+      Planet.mercury
+    }
   ```
 
+  </details>
+
+* <a id='infer-property-types'></a>(<a href='#infer-property-types'>link</a>) **Prefer letting the type of a property be inferred from the right-hand-side value rather than writing the type explicitly on the left-hand side.** [![SwiftFormat: preferInferredTypes](https://img.shields.io/badge/SwiftFormat-preferInferredTypes-7B0051.svg)](https://github.com/nicklockwood/SwiftFormat/blob/master/Rules.md#preferInferredTypes)
+
+  <details>
+
   ```swift
-  enum Direction {
-    case left
-    case right
-  }
+  // WRONG
+  let sun: Star = .init(mass: 1.989e30)
+  let earth: Planet = .earth
 
-  func someDirection() -> Direction {
-    // WRONG
-    return Direction.left
+  // RIGHT
+  let sun = Star(mass: 1.989e30)
+  let earth = Planet.earth
 
-    // RIGHT
-    return .left
+  // ALSO RIGHT: Explicit types are required when there is no right-hand-side value.
+  let sun: Star
+  let earth: Planet
+
+  // ALSO RIGHT: Explicit types can be necessary when the right-hand side has
+  // a different type from the one written explicitly on the left-hand side.
+  let naturalSatellite: PlanetaryBody? = Moon(mass: 7.347e22)
+  let moon: PlanetaryBody? = nil // nil literals are typeless
+  let numberOfPlanets: UInt = 8 // integer literals default to `Int`
+  let sunMass: CGFloat = 1.989e30 // floating-point literals default to `Double`
+  let planets: [Planet] = [] // empty collection literals are typeless
+
+  // ALSO RIGHT: Some of the examples above can also be written idiomatically without an explicit type on
+  // the left-hand-side, by instead giving the right-hand side value an explicit type. Either style is fine.
+  let numberOfPlanets = UInt(8)
+  let sunMass = CGFloat(1.989e30)
+  let planets = [Planet]()
+  ```
+
+  There are some rarer cases where the inferred type syntax has a different meaning than the explicit type syntax. In these cases, the explicit type syntax is still permitted:
+
+  ```swift
+  extension String {
+    static let earth = "Earth"
+  }
+
+  // RIGHT: If the property's type is optional, moving the optional type 
+  // to the right-hand side may result in invalid code.  
+  let planetName: String? = .earth
+
+  // WRONG: fails with "error: type 'String?' has no member 'foo'"
+  let planetName = String?.earth
+  ```
+
+  ```swift
+  struct SaturnOutline: ShapeStyle { ... }
+
+  extension ShapeStyle where Self == SaturnOutline {
+    static var saturnOutline: SaturnOutline { 
+      SaturnOutline() 
+    }
   }
+
+  // RIGHT: If the property's type is an existential / protocol type, moving the type
+  // to the right-hand side will result in invalid code if the value is defined in an
+  // extension like `extension ShapeStyle where Self == SaturnOutline`.
+  // SwiftFormat autocorrect detects this case by checking for the existential `any` keyword.
+  let myShape1: any ShapeStyle = .saturnOutline
+
+  // WRONG: fails with "error: static member 'saturnOutline' cannot be used on protocol metatype '(any ShapeStyle).Type'"
+  let myShape2 = (any ShapeStyle).myShape
   ```
 
   </details>

Sources/AirbnbSwiftFormatTool/airbnb.swiftformat

@@ -100,4 +100,5 @@
 --rules wrapMultilineConditionalAssignment
 --rules blankLineAfterMultilineSwitchCase
 --rules consistentSwitchStatementSpacing
---rules semicolons
+--rules semicolons
+--rules preferInferredTypes