Options: Add new option kind that consumes remaining arguments

[hans]

Summary

This adds KIND_REMAINING_ARGS, a class of options that consume all remaining arguments on the command line.

This will be used to support /link in clang-cl, which is used to forward all remaining arguments to the linker.

It also allows us to remove the hard-coded handling of "--", allowing clients (clang and lld) to implement that functionality themselves with this new option class.

Please take a look!

[rnk]

LGTM

lib/Option/OptTable.cpp

264

I actually kind of liked having this logic here so we shared it with clang and lld, but I guess it's cleaner to let the tool decide what to do with the arguments after --.

[hans]

Closed by commit rL188314 (authored by @hans).

include/llvm/Option/OptParser.td

 // An option which is which takes multiple (separate) arguments.
 def KIND_MULTIARG : OptionKind<"MultiArg">;
 // An option which is either joined to its (non-empty) value, or followed by its
 // value.
 def KIND_JOINED_OR_SEPARATE : OptionKind<"JoinedOrSeparate">;
 // An option which is both joined to its (first) value, and followed by its
 // (second) value.
 def KIND_JOINED_AND_SEPARATE : OptionKind<"JoinedAndSeparate">;
+// An option which consumes all remaining arguments if there are any.
+def KIND_REMAINING_ARGS : OptionKind<"RemainingArgs">;
 
 // Define the option flags.
 
 class OptionFlag {}
 
 // HelpHidden - The option should not be displayed in --help, even if it has
 // help text. Clients *can* use this in conjunction with the OptTable::PrintHelp
 // arguments to implement hidden help groups.

include/llvm/Option/Option.h

 public:
   enum OptionClass {
     GroupClass = 0,
     InputClass,
     UnknownClass,
     FlagClass,
     JoinedClass,
     SeparateClass,
+    RemainingArgsClass,
     CommaJoinedClass,
     MultiArgClass,
     JoinedOrSeparateClass,
     JoinedAndSeparateClass
   };
 
   enum RenderStyleKind {
     RenderCommaJoinedStyle,
RenderStyleKind getRenderStyle() const {
     case JoinedAndSeparateClass:
       return RenderJoinedStyle;
     case CommaJoinedClass:
       return RenderCommaJoinedStyle;
     case FlagClass:
     case SeparateClass:
     case MultiArgClass:
     case JoinedOrSeparateClass:
+    case RemainingArgsClass:
       return RenderSeparateStyle;
     }
     llvm_unreachable("Unexpected kind!");
   }
 
   /// Test if this option has the flag \a Val.
   bool hasFlag(unsigned Val) const {
     return Info->Flags & Val;

lib/Option/OptTable.cpp

InputArgList *OptTable::ParseArgs(const char *const *ArgBegin,
   while (Index < End) {
     // Ignore empty arguments (other things may still take them as arguments).
     StringRef Str = Args->getArgString(Index);
     if (Str == "") {
       ++Index;
       continue;
     }
 
+    // FIXME: Remove once clients are updated to use a KIND_REMAINING_ARGS
+    // option to handle this explicitly instead.
     if (Str == "--") {
       // Everything after -- is a filename.
       ++Index;
 
       assert(TheInputOptionID != 0 && "Invalid input option ID.");
       while (Index < End) {
         Args->append(new Arg(getOption(TheInputOptionID),
                              Args->getArgString(Index), Index,
                              Args->getArgString(Index)));
static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) {
 
   case Option::MultiArgClass:
     llvm_unreachable("Cannot print metavar for this kind of option.");
 
   case Option::FlagClass:
     break;
 
   case Option::SeparateClass: case Option::JoinedOrSeparateClass:
+  case Option::RemainingArgsClass:
     Name += ' ';
     // FALLTHROUGH
   case Option::JoinedClass: case Option::CommaJoinedClass:
   case Option::JoinedAndSeparateClass:
     if (const char *MetaVarName = Opts.getOptionMetaVar(Id))
       Name += MetaVarName;
     else
       Name += "<value>";

lib/Option/Option.cpp

#define P(N) case N: llvm::errs() << #N; break
     P(UnknownClass);
     P(FlagClass);
     P(JoinedClass);
     P(SeparateClass);
     P(CommaJoinedClass);
     P(MultiArgClass);
     P(JoinedOrSeparateClass);
     P(JoinedAndSeparateClass);
+    P(RemainingArgsClass);
 #undef P
   }
 
   if (Info->Prefixes) {
     llvm::errs() << " Prefixes:[";
     for (const char * const *Pre = Info->Prefixes; *Pre != 0; ++Pre) {
       llvm::errs() << '"' << *Pre << (*(Pre + 1) == 0 ? "\"" : "\", ");
     }
case JoinedAndSeparateClass:
     // Always matches.
     Index += 2;
     if (Index > Args.getNumInputArgStrings())
       return 0;
 
     return new Arg(UnaliasedOption, Spelling, Index - 2,
                    Args.getArgString(Index - 2) + ArgSize,
                    Args.getArgString(Index - 1));
+  case RemainingArgsClass: {
+    // Matches iff this is an exact match.
+    // FIXME: Avoid strlen.
+    if (ArgSize != strlen(Args.getArgString(Index)))
+      return 0;
+    Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
+    while (Index < Args.getNumInputArgStrings())
+      A->getValues().push_back(Args.getArgString(Index++));
+    return A;
+  }
   default:
     llvm_unreachable("Invalid option kind!");
   }
 }

unittests/Option/OptionParsingTest.cpp

TEST(Option, DashDash) {
   const char *MyArgs[] = { "-A", "--", "-B", "--" };
   OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
   EXPECT_TRUE(AL->hasArg(OPT_A));
   EXPECT_FALSE(AL->hasArg(OPT_B));
   EXPECT_EQ(AL->getAllArgValues(OPT_INPUT).size(), 2U);
   EXPECT_EQ(AL->getAllArgValues(OPT_INPUT)[0], "-B");
   EXPECT_EQ(AL->getAllArgValues(OPT_INPUT)[1], "--");
 }
+
+TEST(Option, SlurpEmpty) {
+  TestOptTable T;
+  unsigned MAI, MAC;
+
+  const char *MyArgs[] = { "-A", "-slurp" };
+  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  EXPECT_TRUE(AL->hasArg(OPT_A));
+  EXPECT_TRUE(AL->hasArg(OPT_Slurp));
+  EXPECT_EQ(AL->getAllArgValues(OPT_Slurp).size(), 0);
+}
+
+TEST(Option, Slurp) {
+  TestOptTable T;
+  unsigned MAI, MAC;
+
+  const char *MyArgs[] = { "-A", "-slurp", "-B", "--", "foo" };
+  OwningPtr<InputArgList> AL(T.ParseArgs(MyArgs, array_endof(MyArgs), MAI, MAC));
+  EXPECT_EQ(AL->size(), 2U);
+  EXPECT_TRUE(AL->hasArg(OPT_A));
+  EXPECT_FALSE(AL->hasArg(OPT_B));
+  EXPECT_TRUE(AL->hasArg(OPT_Slurp));
+  EXPECT_EQ(AL->getAllArgValues(OPT_Slurp).size(), 3U);
+  EXPECT_EQ(AL->getAllArgValues(OPT_Slurp)[0], "-B");
+  EXPECT_EQ(AL->getAllArgValues(OPT_Slurp)[1], "--");
+  EXPECT_EQ(AL->getAllArgValues(OPT_Slurp)[2], "foo");
+}

unittests/Option/Opts.td

 
 def H : Flag<["-"], "H">, Flags<[HelpHidden]>;
 
 def my_group : OptionGroup<"my group">;
 def I : Flag<["-"], "I">, Alias<H>, Group<my_group>;
 
 def J : Flag<["-"], "J">, Alias<B>, AliasArgs<["foo"]>;
 def Joo : Flag<["-"], "Joo">, Alias<B>, AliasArgs<["bar"]>;
+
+def Slurp : Option<["-"], "slurp", KIND_REMAINING_ARGS>;