@Argument String arrays with .unconditionalRemaining repeat arguments

[glessard]

When using an @Argument that parses to a [String] using the .unconditionalRemaining parsing strategy, command-line arguments that start with "--", "/", "+" and such behave as expected. However an argument that starts with a single dash ("-") appears to be appended to the array as many times as it has characters — as long as the 2nd character isn't also "-".

ArgumentParser version:
81b8064dbd99cf75a4734fa64efe5e680d0b4d9c
Swift version:
Apple Swift version 5.2 (swiftlang-1103.0.30 clang-1103.0.30)
Target: x86_64-apple-darwin19.3.0

Checklist

• If possible, I've reproduced the issue using the master branch of this package
• I've searched for existing GitHub issues

Steps to Reproduce

Using this simple program:

import ArgumentParser
public struct Options: ParsableCommand {
  @Argument(parsing: .unconditionalRemaining) public var arguments: [String]
}

let options = Options.parseOrExit()
print(options.arguments)

$ swift run options
[]
$ swift run options blah -a
["blah", "-a"]
$ swift run options blah -a -bb -ccc --dddd

Expected behavior

For the third command from above, I expected the output to be:
["blah", "-a", "-bb", "-ccc", "--dddd"]

Actual behavior

The output is actually:
["blah", "-a", "-bb", "-bb", "-bb", "-ccc", "-ccc", "-ccc", "-ccc", "--dddd"]

[glessard]

The correct behaviour isn't obvious.
If I modify the ParsableArguments from testParsing_repeatingUnconditionalArgument:

struct Foozle: ParsableArguments {
  @Flag(name: .shortAndLong) var verbose: Bool
  @Argument(parsing: .unconditionalRemaining) var names: [String]
}

extension RepeatingEndToEndTests {
  func testParsing_repeatingUnconditionalArgument_9() throws {
    AssertParse(Foozle.self, ["something", "--other", "-variant", "-alternate"]) { foozle in
      XCTAssertEqual(foozle.verbose, true)
      XCTAssertEqual(foozle.names, ["something", "--other", "-ariant", "-alternate"]) /* FAILS */
    }
}

What is the expected outcome? Given that the 'v' from -variant get used to set the verbose flag, how is the rest of that string handled? Should it be different from how the string -alternate is handled, given that none of its characters can get interpreted as a flag?

[natecook1000]

This is a tricky one — I think there are two cases here:

1. There aren’t any flags or options with .short names that match part of the single-dashed input. In this case, the whole input should just show up one time in the array.

2. A flag or option matches part of the single-dashed input. This kind of input should be an error, the same as if you wrote my-command -fv to a command that has only defined -f.

[glessard]

I like your #2. I hadn't thought of it that way, and it's quite reasonable. I was trying to convince myself that passing along an altered string would make sense, and you convinced me that it doesn't.