Improve parsing performance

Sources/ArgumentParser/Parsing/ArgumentDecoder.swift

@@ -35,7 +35,7 @@ final class ArgumentDecoder: Decoder {
     self.usedOrigins = InputOrigin()
 
     // Mark the terminator position(s) as used:
-    values.elements.filter { $0.key == .terminator }.forEach {
+    values.elements.values.filter { $0.key == .terminator }.forEach {
       usedOrigins.formUnion($0.inputOrigin)
     }
   }

Sources/ArgumentParser/Parsing/ArgumentSet.swift

@@ -316,18 +316,20 @@ extension ArgumentSet {
       }
     }
 
-    var result = ParsedValues(elements: [], originalInput: all.originalInput)
-    var usedOrigins = InputOrigin()
+    var result = ParsedValues(elements: [:], originalInput: all.originalInput)
+    var allUsedOrigins = InputOrigin()
 
     try setInitialValues(into: &result)
 
     // Loop over all arguments:
     while let (origin, next) = inputArguments.popNext() {
+      var usedOrigins = InputOrigin()
       defer {
         inputArguments.removeAll(in: usedOrigins)
+        allUsedOrigins.formUnion(usedOrigins)
       }
 
-      switch next {
+      switch next.value {
       case .value:
         // We'll parse positional values later.
         break
@@ -359,9 +361,9 @@ extension ArgumentSet {
     // We have parsed all non-positional values at this point.
     // Next: parse / consume the positional values.
     var unusedArguments = all
-    unusedArguments.removeAll(in: usedOrigins)
+    unusedArguments.removeAll(in: allUsedOrigins)
     try parsePositionalValues(from: unusedArguments, into: &result)
-    
+
     return result
   }
 }
@@ -407,7 +409,7 @@ extension ArgumentSet {
     var argumentStack = unusedInput.elements.filter {
       $0.index.subIndex == .complete
     }.map {
-      (InputOrigin.Element.argumentIndex($0.index), $0.element)
+      (InputOrigin.Element.argumentIndex($0.index), $0)
     }[...]
 
     guard !argumentStack.isEmpty else { return }

Sources/ArgumentParser/Parsing/CommandParser.swift

@@ -97,9 +97,9 @@ extension CommandParser {
     // We should have used up all arguments at this point:
     guard !split.containsNonTerminatorArguments else {
       // Check if one of the arguments is an unknown option
-      for (index, element) in split.elements {
-        if case .option(let argument) = element {
-          throw ParserError.unknownOption(InputOrigin.Element.argumentIndex(index), argument.name)
+      for element in split.elements {
+        if case .option(let argument) = element.value {
+          throw ParserError.unknownOption(InputOrigin.Element.argumentIndex(element.index), argument.name)
         }
       }
 
@@ -296,12 +296,12 @@ extension CommandParser {
 
     // Generate the argument set and parse the argument to find in the set
     let argset = ArgumentSet(current.element)
-    let (_, parsedArgument) = try! parseIndividualArg(argToMatch, at: 0).first!
+    let parsedArgument = try! parseIndividualArg(argToMatch, at: 0).first!
 
     // Look up the specified argument and retrieve its custom completion function
     let completionFunction: ([String]) -> [String]
 
-    switch parsedArgument {
+    switch parsedArgument.value {
     case .option(let parsed):
       guard let matchedArgument = argset.first(matching: parsed),
         case .custom(let f) = matchedArgument.completion.kind
@@ -362,7 +362,7 @@ extension CommandParser {
 extension SplitArguments {
   func contains(_ needle: Name) -> Bool {
     self.elements.contains {
-      switch $0.element {
+      switch $0.value {
       case .option(.name(let name)),
            .option(.nameWithValue(let name, _)):
         return name == needle
@@ -374,7 +374,7 @@ extension SplitArguments {
 
   func contains(anyOf names: [Name]) -> Bool {
     self.elements.contains {
-      switch $0.element {
+      switch $0.value {
       case .option(.name(let name)),
            .option(.nameWithValue(let name, _)):
         return names.contains(name)

Sources/ArgumentParser/Parsing/ParsedValues.swift

@@ -36,7 +36,7 @@ struct ParsedValues {
   }
 
   /// These are the parsed key-value pairs.
-  var elements: [Element] = []
+  var elements: [InputKey: Element] = [:]
 
   /// This is the *original* array of arguments that this was parsed from.
   ///
@@ -50,20 +50,20 @@ extension ParsedValues {
   }
 
   mutating func set(_ element: Element) {
-    if let index = elements.firstIndex(where: { $0.key == element.key }) {
+    if let e = elements[element.key] {
       // Merge the source values. We need to keep track
       // of any previous source indexes we have used for
       // this key.
-      var e = element
-      e.inputOrigin.formUnion(elements[index].inputOrigin)
-      elements[index] = e
+      var element = element
+      element.inputOrigin.formUnion(e.inputOrigin)
+      elements[element.key] = element
     } else {
-      elements.append(element)
+      elements[element.key] = element
     }
   }
 
   func element(forKey key: InputKey) -> Element? {
-    return elements.first(where: { $0.key == key })
+    elements[key]
   }
 
   mutating func update<A>(forKey key: InputKey, inputOrigin: InputOrigin, initial: A, closure: (inout A) -> Void) {