Infer type from property initialization expressions

[gohanlon]

Description

MemberwiseInit currently needs you to explicitly specify the type for properties, even those that are initialized to expressions that contain sufficient type information, e.g. literal values. This manual type specification can feel redundant.

Swift's memberwise init can infer type from arbitrary expressions. Since literals are syntax-level, MemberwiseInit can at least infer types from most literal values. This would both enhance usability and more closely mirror Swift's memberwise init.

Some other expressions where type can be inferred from syntax are as Type expressions, and conditional/operator expressions that compose other expressions from which type can be inferred.

In the common case, instead of:

struct Example {
  var count: Int = 0
}

you could simply do:

struct Example {
  var count = 0
}

This type inference should support all Swift literals that contain sufficient type information, such as Int, Double, String, Bool, Array of literals, and Dictionary of literals, as well as any other expressions whose syntax provides clear type information.

[gohanlon]

An incomplete but more illustrative list showing the breadth of Swift literals whose type information can be inferred from their syntax:

1. Integer Literals

   • Whole numbers (e.g., 1, 42, -7)

2. Floating-Point Literals

   • Decimal (e.g., 3.14, 0.1, -8.3)
   • Hexadecimal (e.g., 0xC.3p0, 0xFp-2)

3. String Literals

   • Regular strings (e.g., "Hello, World!", "Swift")
   • Multiline strings (e.g., """Line1\nLine2""")

4. Boolean Literals

   • true and false

5. Nil Literal

• nil

6. Array Literals

   • Explicit array type initializer (e.g., [CustomType]())
   • Non-empty array of literals (e.g., [1, 2, 3], ["a", "b", "c"])

7. Dictionary Literals

   • Explicit dictionary type initializer (e.g., [KeyType : ValueType]())
   • Non-empty dictionary of literals (e.g., ["key": "value", "name": "John"])

8. Tuple Literals

   • Empty tuple (e.g., ())
   • Non-empty tuple of literals (e.g., (1, "Two", 3.0))

9. Optional Literals

   • Maybe: Wrapped optional literals (e.g., Int?("42"), String?(nil))

10. Object Literals (Swift 5.1+)

    • Maybe: Color (e.g., #colorLiteral(red: 1, green: 1, blue: 1, alpha: 1))
    • Maybe: Image (e.g., #imageLiteral(resourceName: "swift.png"))
    • Maybe: File reference (e.g., #fileLiteral(resourceName: "Info.plist"))

11. Regular Expressions (Swift 5.7+)
- Regex literals (e.g., /[a-z]+/)