[WIP] Add ArgumentSource as the projected value of arguments

Examples/repeat/main.swift

@@ -19,11 +19,15 @@ struct Repeat: ParsableCommand {
     var includeCounter: Bool
 
     @Argument(help: "The phrase to repeat.")
-    var phrase: String
+    var phrase: [String]
 
     func run() throws {
         let repeatCount = count ?? .max
 
+        dump($count)
+        dump($includeCounter)
+        dump($phrase)
+
         for i in 1...repeatCount {
             if includeCounter {
                 print("\(i): \(phrase)")

Sources/ArgumentParser/Parsable Properties/Argument.swift

@@ -40,22 +40,31 @@ public struct Argument<Value>:
   public var wrappedValue: Value {
     get {
       switch _parsedValue {
-      case .value(let v):
+      case .value(let v, _):
         return v
       case .definition:
         fatalError(directlyInitializedError)
       }
     }
     set {
-      _parsedValue = .value(newValue)
+      _parsedValue = .value(newValue, _parsedValue.source ?? ArgumentSource(source: []))
+    }
+  }
+
+  public var projectedValue: ArgumentSource {
+    switch _parsedValue {
+    case .value(_, let source):
+      return source
+    case .definition:
+      fatalError(directlyInitializedError)
     }
   }
 }
 
 extension Argument: CustomStringConvertible {
   public var description: String {
     switch _parsedValue {
-    case .value(let v):
+    case .value(let v, _):
       return String(describing: v)
     case .definition:
       return "Argument(*definition*)"

Sources/ArgumentParser/Parsable Properties/ArgumentSource.swift

@@ -0,0 +1,15 @@
+//===----------------------------------------------------------*- swift -*-===//
+//
+// This source file is part of the Swift Argument Parser open source project
+//
+// Copyright (c) 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+//
+//===----------------------------------------------------------------------===//
+
+public struct ArgumentSource {
+  public var source: [(value: String, position: Int)]
+}
+

Sources/ArgumentParser/Parsable Properties/Flag.swift

@@ -52,22 +52,31 @@ public struct Flag<Value>: Decodable, ParsedWrapper {
   public var wrappedValue: Value {
     get {
       switch _parsedValue {
-      case .value(let v):
+      case .value(let v, _):
         return v
       case .definition:
         fatalError(directlyInitializedError)
       }
     }
     set {
-      _parsedValue = .value(newValue)
+      _parsedValue = .value(newValue, _parsedValue.source ?? ArgumentSource(source: []))
+    }
+  }
+
+  public var projectedValue: ArgumentSource {
+    switch _parsedValue {
+    case .value(_, let source):
+      return source
+    case .definition:
+      fatalError(directlyInitializedError)
     }
   }
 }
 
 extension Flag: CustomStringConvertible {
   public var description: String {
     switch _parsedValue {
-    case .value(let v):
+    case .value(let v, _):
       return String(describing: v)
     case .definition:
       return "Flag(*definition*)"

Sources/ArgumentParser/Parsable Properties/Option.swift

@@ -42,22 +42,31 @@ public struct Option<Value>: Decodable, ParsedWrapper {
   public var wrappedValue: Value {
     get {
       switch _parsedValue {
-      case .value(let v):
+      case .value(let v, _):
         return v
       case .definition:
         fatalError(directlyInitializedError)
       }
     }
     set {
-      _parsedValue = .value(newValue)
+      _parsedValue = .value(newValue, _parsedValue.source ?? ArgumentSource(source: []))
+    }
+  }
+
+  public var projectedValue: ArgumentSource {
+    switch _parsedValue {
+    case .value(_, let source):
+      return source
+    case .definition:
+      fatalError(directlyInitializedError)
     }
   }
 }
 
 extension Option: CustomStringConvertible {
   public var description: String {
     switch _parsedValue {
-    case .value(let v):
+    case .value(let v, _):
       return String(describing: v)
     case .definition:
       return "Option(*definition*)"

Sources/ArgumentParser/Parsable Properties/OptionGroup.swift

@@ -44,7 +44,7 @@ public struct OptionGroup<Value: ParsableArguments>: Decodable, ParsedWrapper {
     if let d = decoder as? SingleValueDecoder,
       let value = try? d.previousValue(Value.self)
     {
-      self.init(_parsedValue: .value(value))
+      self.init(_parsedValue: .value(value, ArgumentSource(source: [])))
     } else {
       try self.init(_decoder: decoder)
       if let d = decoder as? SingleValueDecoder {
@@ -63,22 +63,22 @@ public struct OptionGroup<Value: ParsableArguments>: Decodable, ParsedWrapper {
   public var wrappedValue: Value {
     get {
       switch _parsedValue {
-      case .value(let v):
+      case .value(let v, _):
         return v
       case .definition:
         fatalError(directlyInitializedError)
       }
     }
     set {
-      _parsedValue = .value(newValue)
+      _parsedValue = .value(newValue, _parsedValue.source ?? ArgumentSource(source: []))
     }
   }
 }
 
 extension OptionGroup: CustomStringConvertible {
   public var description: String {
     switch _parsedValue {
-    case .value(let v):
+    case .value(let v, _):
       return String(describing: v)
     case .definition:
       return "OptionGroup(*definition*)"

Sources/ArgumentParser/Parsing/Parsed.swift

@@ -18,12 +18,26 @@ enum Parsed<Value> {
     var makeSet: (InputKey) -> ArgumentSet
   }
 
-  case value(Value)
+  case value(Value, ArgumentSource)
   case definition(Definition)
 
   internal init(_ makeSet: @escaping (InputKey) -> ArgumentSet) {
     self = .definition(Definition(makeSet: makeSet))
   }
+
+  var value: Value? {
+    switch self {
+    case .value(let v, _): return v
+    case .definition: return nil
+    }
+  }
+
+  var source: ArgumentSource? {
+    switch self {
+    case .value(_, let s): return s
+    case .definition: return nil
+    }
+  }
 }
 
 /// A type that wraps a `Parsed` instance to act as a property wrapper.
@@ -54,7 +68,14 @@ extension ParsedWrapper {
       throw ParserError.noValue(forKey: d.parsedElement?.key ?? d.key)
     }
 
-    self.init(_parsedValue: .value(value))
+    let sourceIndexes: [Int] = d.parsedElement!.inputOrigin.elements.compactMap { x -> Int? in
+      guard case .argumentIndex(let i) = x else { return nil }
+      return i.inputIndex.rawValue
+    }
+    let sourceValues = sourceIndexes.map { d.underlying.values.originalInput[$0] }
+    let source = ArgumentSource(source: Array(zip(sourceValues, sourceIndexes)))
+
+    self.init(_parsedValue: .value(value, source))
   }
 
   func argumentSet(for key: InputKey) -> ArgumentSet {
@@ -70,18 +91,25 @@ extension ParsedWrapper {
 extension ParsedWrapper where Value: Decodable {
   init(_decoder: Decoder) throws {
     var value: Value
+    let source: ArgumentSource
 
     do {
       value = try Value.init(from: _decoder)
+      source = ArgumentSource(source: [])
     } catch {
-      if let d = _decoder as? SingleValueDecoder,
-        let v = d.parsedElement?.value as? Value {
-        value = v
-      } else {
+      guard let d = _decoder as? SingleValueDecoder,
+        let v = d.parsedElement?.value as? Value else {
         throw error
       }
-    }
+      value = v
 
-    self.init(_parsedValue: .value(value))
+      let sourceIndexes: [Int] = d.parsedElement!.inputOrigin.elements.compactMap { x -> Int? in
+        guard case .argumentIndex(let i) = x else { return nil }
+        return i.inputIndex.rawValue
+      }
+      let sourceValues = sourceIndexes.map { d.underlying.values.originalInput[$0] }
+      source = ArgumentSource(source: Array(zip(sourceValues, sourceIndexes)))
+    }
+    self.init(_parsedValue: .value(value, source))
   }
 }

Sources/ArgumentParser/Usage/HelpCommand.swift

@@ -36,11 +36,17 @@ struct HelpCommand: ParsableCommand {
 
   init(from decoder: Decoder) throws {
     let container = try decoder.container(keyedBy: CodingKeys.self)
-    self._subcommands = Argument(_parsedValue: .value(try container.decode([String].self, forKey: .subcommands)))
+    self._subcommands = Argument(
+      _parsedValue: .value(
+        try container.decode([String].self, forKey: .subcommands),
+        ArgumentSource(source: [])))
   }
 
   init(commandStack: [ParsableCommand.Type]) {
     self.commandStack = commandStack
-    self._subcommands = Argument(_parsedValue: .value(commandStack.map { $0._commandName }))
+    self._subcommands = Argument(
+      _parsedValue: .value(
+        commandStack.map { $0._commandName },
+        ArgumentSource(source: [])))
   }
 }