Allow normal Swift default property initialization syntax

Sources/ArgumentParser/Parsable Properties/Option.swift

@@ -70,6 +70,26 @@ extension Option: DecodableParsedWrapper where Value: Decodable {}
 // MARK: Property Wrapper Initializers
 
 extension Option where Value: ExpressibleByArgument {
+  /// Creates a property with an optional default value, intended to be called by other constructors to centralize logic.
+  ///
+  /// This private `init` allows us to expose multiple other similar constructors to allow for standard default property initialization while reducing code duplication.
+  private init(
+    name: NameSpecification = .long,
+    initial: Value? = nil,
+    parsingStrategy: SingleValueParsingStrategy = .next,
+    help: ArgumentHelp? = nil
+  ) {
+    self.init(_parsedValue: .init { key in
+      ArgumentSet(
+        key: key,
+        kind: .name(key: key, specification: name),
+        parsingStrategy: ArgumentDefinition.ParsingStrategy(parsingStrategy),
+        parseType: Value.self,
+        name: name,
+        default: initial, help: help)
+      })
+  }
+
   /// Creates a property that reads its value from a labeled option.
   ///
   /// - Parameters:
@@ -79,21 +99,67 @@ extension Option where Value: ExpressibleByArgument {
   ///   - parsingStrategy: The behavior to use when looking for this option's
   ///     value.
   ///   - help: Information about how to use this option.
+  @available(*, deprecated, message: "Use regular property initialization for default values (`var foo: String = \"bar\"`)")
   public init(
     name: NameSpecification = .long,
     default initial: Value? = nil,
     parsing parsingStrategy: SingleValueParsingStrategy = .next,
     help: ArgumentHelp? = nil
   ) {
-    self.init(_parsedValue: .init { key in
-      ArgumentSet(
-        key: key,
-        kind: .name(key: key, specification: name),
-        parsingStrategy: ArgumentDefinition.ParsingStrategy(parsingStrategy),
-        parseType: Value.self,
-        name: name,
-        default: initial, help: help)
-      })
+    self.init(
+      name: name,
+      initial: initial,
+      parsingStrategy: parsingStrategy,
+      help: help
+    )
+  }
+
+  /// Creates a property with a default value provided by standard Swift default value syntax.
+  ///
+  /// For instance, the following are now equivalent:
+  /// - `@Option(default: "bar") var foo: String`
+  /// - `@Option() var foo: String = "bar"`
+  ///
+  /// This syntax allows defaults to be set for options much more naturally for the developer.
+  ///
+  /// - Parameters:
+  ///   - wrappedValue: A default value to use for this property, provided implicitly by the compiler during `propertyWrapper` initialization.
+  ///   - name: A specification for what names are allowed for this flag.
+  ///   - parsingStrategy: The behavior to use when looking for this option's value.
+  ///   - help: Information about how to use this option.
+  public init(
+    wrappedValue: Value,
+    name: NameSpecification = .long,
+    parsing parsingStrategy: SingleValueParsingStrategy = .next,
+    help: ArgumentHelp? = nil
+  ) {
+     self.init(
+      name: name,
+      initial: wrappedValue,
+      parsingStrategy: parsingStrategy,
+      help: help
+    )
+  }
+
+  /// Creates a property with no default value.
+  ///
+  /// With the addition of standard default property initialization syntax and the deprecation of the previous `init` with a `default` parameter, we must also provide a separate `init` with no default for when the older method is eventually removed.
+  ///
+  /// - Parameters:
+  ///   - name: A specification for what names are allowed for this flag.
+  ///   - parsingStrategy: The behavior to use when looking for this option's value.
+  ///   - help: Information about how to use this option.
+  public init(
+    name: NameSpecification = .long,
+    parsing parsingStrategy: SingleValueParsingStrategy = .next,
+    help: ArgumentHelp? = nil
+  ) {
+     self.init(
+      name: name,
+      initial: nil,
+      parsingStrategy: parsingStrategy,
+      help: help
+    )
   }
 }
 
@@ -305,7 +371,90 @@ extension Option {
       return ArgumentSet(alternatives: [arg])
       })
   }
-
+
+  /// Creates a property that reads its value from a labeled option, parsing
+  /// with the given closure.
+  ///
+  /// - Parameters:
+  ///   - name: A specification for what names are allowed for this flag.
+  ///   - initial: A default value to use for this property. If `initial` is
+  ///     `nil`, this option and value are required from the user.
+  ///   - parsingStrategy: The behavior to use when looking for this option's
+  ///     value.
+  ///   - help: Information about how to use this option.
+  ///   - transform: A closure that converts a string into this property's
+  ///     type or throws an error.
+  @available(*, deprecated, message: "Use regular property initialization for default values (`var foo: String = \"bar\"`)")
+  public init(
+    name: NameSpecification = .long,
+    default initial: Value? = nil,
+    parsing parsingStrategy: SingleValueParsingStrategy = .next,
+    help: ArgumentHelp? = nil,
+    transform: @escaping (String) throws -> Value
+  ) {
+     self.init(
+      name: name,
+      initial: initial,
+      parsingStrategy: parsingStrategy,
+      help: help,
+      transform: transform
+    )
+  }
+
+  /// Creates a property with a default value provided by standard Swift default value syntax, parsing with the given closure.
+  ///
+  /// For instance, the following are now equivalent:
+  /// - `@Option(default: "bar", transform: someFunction) var foo: String`
+  /// - `@Option(transform: someFunction) var foo: String = "bar"`
+  ///
+  /// This syntax allows defaults to be set for options much more naturally for the developer.
+  ///
+  /// - Parameters:
+  ///   - wrappedValue: A default value to use for this property, provided implicitly by the compiler during `propertyWrapper` initialization.
+  ///   - name: A specification for what names are allowed for this flag.
+  ///   - parsingStrategy: The behavior to use when looking for this option's value.
+  ///   - help: Information about how to use this option.
+  ///   - transform: A closure that converts a string into this property's type or throws an error.
+   public init(
+    wrappedValue: Value,
+    name: NameSpecification = .long,
+    parsing parsingStrategy: SingleValueParsingStrategy = .next,
+    help: ArgumentHelp? = nil,
+    transform: @escaping (String) throws -> Value
+  ) {
+    self.init(
+      name: name,
+      initial: wrappedValue,
+      parsingStrategy: parsingStrategy,
+      help: help,
+      transform: transform
+    )
+  }
+
+  /// Creates a property with no default value, parsing with the given closure.
+  ///
+  /// With the addition of standard default property initialization syntax and the deprecation of the previous `init` with a `default` parameter, we must also provide a separate `init` with no default for when the older method is eventually removed.
+  ///
+  /// - Parameters:
+  ///   - name: A specification for what names are allowed for this flag.
+  ///   - parsingStrategy: The behavior to use when looking for this option's value.
+  ///   - help: Information about how to use this option.
+  ///   - transform: A closure that converts a string into this property's type or throws an error.
+  public init(
+    name: NameSpecification = .long,
+    parsing parsingStrategy: SingleValueParsingStrategy = .next,
+    help: ArgumentHelp? = nil,
+    transform: @escaping (String) throws -> Value
+  ) {
+    self.init(
+      name: name,
+      initial: nil,
+      parsingStrategy: parsingStrategy,
+      help: help,
+      transform: transform
+    )
+  }
+
   /// Creates an array property that reads its values from zero or more
   /// labeled options.
   ///

Tests/ArgumentParserEndToEndTests/DefaultsEndToEndTests.swift

@@ -373,3 +373,71 @@ extension DefaultsEndToEndTests {
   }
 }
 
+
+fileprivate func exclaim(_ input: String) throws -> String {
+  return input + "!"
+}
+
+fileprivate struct OptionPropertyInitArguments_Default: ParsableArguments {
+  @Option
+  var data: String = "test"
+
+  @Option(transform: exclaim)
+  var transformedData: String = "test"
+}
+
+fileprivate struct OptionPropertyInitArguments_NoDefault_NoTransform: ParsableArguments {
+  @Option()
+  var data: String
+}
+
+fileprivate struct OptionPropertyInitArguments_NoDefault_Transform: ParsableArguments {
+  @Option(transform: exclaim)
+  var transformedData: String
+}
+
+extension DefaultsEndToEndTests {
+  /// Tests that using default property initialization syntax parses the default value for the argument when nothing is provided from the command-line.
+  func testParsing_OptionPropertyInit_Default_NoTransform_UseDefault() throws {
+    AssertParse(OptionPropertyInitArguments_Default.self, []) { arguments in
+      XCTAssertEqual(arguments.data, "test")
+    }
+  }
+
+  /// Tests that using default property initialization syntax parses the command-line-provided value for the argument when provided.
+  func testParsing_OptionPropertyInit_Default_NoTransform_OverrideDefault() throws {
+    AssertParse(OptionPropertyInitArguments_Default.self, ["--data", "test2"]) { arguments in
+      XCTAssertEqual(arguments.data, "test2")
+    }
+  }
+
+  /// Tests that *not* providing a default value still parses the argument correctly from the command-line.
+  /// This test is almost certainly duplicated by others in the repository, but allows for quick use of test filtering during development on the initialization functionality.
+  func testParsing_OptionPropertyInit_NoDefault_NoTransform() throws {
+    AssertParse(OptionPropertyInitArguments_NoDefault_NoTransform.self, ["--data", "test"]) { arguments in
+      XCTAssertEqual(arguments.data, "test")
+    }
+  }
+
+  /// Tests that using default property initialization syntax on a property with a `transform` function provided parses the default value for the argument when nothing is provided from the command-line.
+  func testParsing_OptionPropertyInit_Default_Transform_UseDefault() throws {
+    AssertParse(OptionPropertyInitArguments_Default.self, []) { arguments in
+      XCTAssertEqual(arguments.transformedData, "test")
+    }
+  }
+
+  /// Tests that using default property initialization syntax on a property with a `transform` function provided parses and transforms the command-line-provided value for the argument when provided.
+  func testParsing_OptionPropertyInit_Default_Transform_OverrideDefault() throws {
+    AssertParse(OptionPropertyInitArguments_Default.self, ["--transformed-data", "test2"]) { arguments in
+      XCTAssertEqual(arguments.transformedData, "test2!")
+    }
+  }
+
+  /// Tests that *not* providing a default value for a property with a `transform` function still parses the argument correctly from the command-line.
+  /// This test is almost certainly duplicated by others in the repository, but allows for quick use of test filtering during development on the initialization functionality.
+  func testParsing_OptionPropertyInit_NoDefault_Transform() throws {
+    AssertParse(OptionPropertyInitArguments_NoDefault_Transform.self, ["--transformed-data", "test"]) { arguments in
+      XCTAssertEqual(arguments.transformedData, "test!")
+    }
+  }
+}