[benchmark][Gardening] Declarative ArgumentParser

The `ArgumentParser` now has a configuration phase which specifies the supported arguments and their handling. The configured parser is then executed using the `parse` method which returns the parsed result.

Author: palimondo

benchmark/utils/ArgParse.swift

@@ -119,31 +119,47 @@ func checked<T>(
 
 class ArgumentParser<U> {
     var result: U
-    let validOptions: [String]
-    private let benchArgs: Arguments
+    var validOptions: [String] = []
+    private var benchArgs: Arguments!
+    private var parsers: [() throws -> ()] = []
 
-    init(into result: U, validOptions: [String]) throws {
+    init(into result: U) throws {
         self.result = result
-        self.validOptions = validOptions
-        guard let benchArgs = parseArgs(validOptions) else {
-          throw ArgumentError.general("Failed to parse arguments")
-        }
-        self.benchArgs = benchArgs
     }
 
-    func parseArg<T>(
+    func parse() throws -> U {
+      guard let benchArgs = parseArgs(validOptions) else {
+        throw ArgumentError.general("Failed to parse arguments")
+      }
+      self.benchArgs = benchArgs
+      try parsers.forEach { try $0() } // parse all arguments
+      return result
+    }
+
+    func addArgument<T>(
       _ name: String?,
       _ property: WritableKeyPath<U, T>,
       defaultValue: T? = nil,
-      parser parse: (String) throws -> T? = { _ in nil }
+      parser: @escaping (String) throws -> T? = { _ in nil }
+    ) {
+      if let name = name { validOptions.append(name) }
+      parsers.append(
+        { try self.parseArgument(name, property, defaultValue, parser) })
+    }
+
+    func parseArgument<T>(
+      _ name: String?,
+      _ property: WritableKeyPath<U, T>,
+      _ defaultValue: T?,
+      _ parse: (String) throws -> T?
     ) throws {
       if let name = name, let value = benchArgs.optionalArgsMap[name] {
         guard !value.isEmpty || defaultValue != nil
           else { throw ArgumentError.missingValue(name) }
 
         result[keyPath: property] = (value.isEmpty)
           ? defaultValue!
-          : try checked(parse, value, argument:name)
+          : try checked(parse, value, argument: name)
       } else if name == nil {
         result[keyPath: property] = benchArgs.positionalArgs as! T
       }

benchmark/utils/DriverUtils.swift

@@ -72,12 +72,6 @@ struct TestConfig {
       var tests: [String]?
     }
 
-    let p = try ArgumentParser(into: PartialTestConfig(), validOptions: [
-      "--iter-scale", "--num-samples", "--num-iters",
-      "--verbose", "--delim", "--list", "--sleep",
-      "--tags", "--skip-tags", "--help"
-    ])
-
     func tags(tags: String) throws -> Set<BenchmarkCategory> {
       // We support specifying multiple tags by splitting on comma, i.e.:
       //  --tags=Array,Dictionary
@@ -87,21 +81,22 @@ struct TestConfig {
           try checked({ BenchmarkCategory(rawValue: $0) }, $0) })
     }
 
-    // Parse command line arguments
-    try p.parseArg("--iter-scale", \.iterationScale) { Int($0) }
-    try p.parseArg("--num-iters", \.fixedNumIters) { UInt($0) }
-    try p.parseArg("--num-samples", \.numSamples)  { Int($0) }
-    try p.parseArg("--verbose", \.verbose, defaultValue: true)
-    try p.parseArg("--delim", \.delim) { $0 }
-    try p.parseArg("--tags", \PartialTestConfig.tags, parser: tags)
-    try p.parseArg("--skip-tags", \PartialTestConfig.skipTags,
+    // Configure the command line argument parser
+    let p = try ArgumentParser(into: PartialTestConfig())
+    p.addArgument("--iter-scale", \.iterationScale) { Int($0) }
+    p.addArgument("--num-iters", \.fixedNumIters) { UInt($0) }
+    p.addArgument("--num-samples", \.numSamples)  { Int($0) }
+    p.addArgument("--verbose", \.verbose, defaultValue: true)
+    p.addArgument("--delim", \.delim) { $0 }
+    p.addArgument("--tags", \PartialTestConfig.tags, parser: tags)
+    p.addArgument("--skip-tags", \PartialTestConfig.skipTags,
                     defaultValue: [], parser: tags)
-    try p.parseArg("--sleep", \.afterRunSleep) { Int($0) }
-    try p.parseArg("--list", \.action, defaultValue: .listTests)
-    try p.parseArg("--help", \.action, defaultValue: .help(p.validOptions))
-    try p.parseArg(nil, \.tests) // positional arguments
+    p.addArgument("--sleep", \.afterRunSleep) { Int($0) }
+    p.addArgument("--list", \.action, defaultValue: .listTests)
+    p.addArgument("--help", \.action, defaultValue: .help(p.validOptions))
+    p.addArgument(nil, \.tests) // positional arguments
 
-    let c = p.result
+    let c = try p.parse()
 
     // Configure from the command line arguments, filling in the defaults.
     delim = c.delim ?? ","