[Support] Use variadic templates instead of varargs in CommandLineFlags.h ValueClass

[EricWF]

Summary

This refactoring was informally requested on IRC.

[EricWF]

Use fewer templates.

[mehdi_amini]

Thanks Eric, can you look at: D25342

[EricWF]

Thanks Eric, can you look at: D25342

Yep. Looks like you beat me to it! I'll leave this revision open until one or the other moves.

[EricWF]

Abandoning in favor of D25342.

include/llvm/Support/CommandLine.h

 // that the values list must always have a 0 at the end of the list to indicate
 // that the list has ended.
 //
 template <class DataType> class ValuesClass {
   // Use a vector instead of a map, because the lists should be short,
   // the overhead is less, and most importantly, it keeps them in the order
   // inserted so we can print our option out nicely.
   SmallVector<std::pair<StringRef , std::pair<int, StringRef >>, 4> Values;
-  void processValues(va_list Vals);
+
+  template <class ENameT, class EValT, class EDescT, class... Remaining>
+  void processArgs(ENameT Name, EValT Val, EDescT Desc, Remaining... Args) {
+    static_assert(std::is_same<const char *, ENameT>::value,
+                  "expected string literal argument");
+    static_assert(std::is_same<int, EValT>::value, "expected integer argument");
+    static_assert(std::is_same<const char *, EDescT>::value,
+                  "expected string literal argument");
+    auto EnumVal = static_cast<DataType>(Val);
+    Values.push_back(std::make_pair(StringRef(Name),
+                                    std::make_pair(EnumVal, StringRef(Desc))));
+    processArgs(Args...);
+  }
+
+  template <class SentinalT> void processArgs(SentinalT) {
+    // FIXME: Remove sentinal argument at all of the call sites.
+    static_assert(std::is_same<SentinalT, void *>::value,
+                  "incorrect sentinal type");
+  }
 
 public:
+  template <class... Args>
   ValuesClass(StringRef EnumName, DataType Val, StringRef Desc,
-              va_list ValueArgs) {
+              Args... ValueArgs) {
     // Insert the first value, which is required.
     Values.push_back(std::make_pair(EnumName, std::make_pair(Val, Desc)));
-
-    // Process the varargs portion of the values...
-    while (const char *enumName = va_arg(ValueArgs, const char * )) {
-      DataType EnumVal = static_cast<DataType>(va_arg(ValueArgs, int));
-      auto EnumDesc = StringRef(va_arg(ValueArgs, const char * ));
-      Values.push_back(std::make_pair(StringRef(enumName), // Add value to value map
-                                      std::make_pair(EnumVal, EnumDesc)));
-    }
+    processArgs(ValueArgs...);
   }
 
   template <class Opt> void apply(Opt &O) const {
     for (size_t i = 0, e = Values.size(); i != e; ++i)
       O.getParser().addLiteralOption(Values[i].first, Values[i].second.first,
                                      Values[i].second.second);
   }
 };
 
-template <class DataType>
-ValuesClass<DataType> LLVM_END_WITH_NULL
-values(StringRef Arg, DataType Val, StringRef Desc, ...) {
-  va_list ValueArgs;
-  va_start(ValueArgs, Desc);
-  ValuesClass<DataType> Vals(Arg, Val, Desc, ValueArgs);
-  va_end(ValueArgs);
+template <class DataType, class... Args>
+ValuesClass<DataType> values(StringRef Arg, DataType Val, StringRef Desc,
+                             Args &&... ValueArgs) {
+  ValuesClass<DataType> Vals(Arg, Val, Desc, std::forward<Args>(ValueArgs)...);
   return Vals;
 }
 
 //===----------------------------------------------------------------------===//
 // parser class - Parameterizable parser for different data types.  By default,
 // known data types (string, int, bool) have specialized parsers, that do what
 // you would expect.  The default parser, used for data types that are not
 // built-in, uses a mapping table to map specific options to values, which is