Fix Windows command line bug when last token in response file is ""

[neildhar]

Summary

Current state machine for parsing tokens from response files in Windows does not correctly handle the case where the last token is "". The current implementation handles the last token by only adding it if it is not empty, however this does not cover the case where the last token is meant to be the empty string. We can cover this case by checking whether the state machine was last in the UNQUOTED state, which indicates that the last character of the input was a non-whitespace character.

[neildhar]

Ping

[neildhar]

Hi @rnk and @Bigcheese, I was wondering if you would be willing to review this diff.

Thank you!

[amccarth]

I think the fix looks good, but I'd like to see a bit more in the test.

Thanks for taking on this bug.

llvm/unittests/Support/CommandLineTest.cpp

254

It would make the test easier to read if we could use raw string literals for these kinds of inputs. Does LLVM style permit that?

257

I'm mildly concerned that in the future someone may come in and append another argument to the end in order to test some other case, and thus invalidate this test.

Can you add a comment that this test is (among other things) explicitly testing the case of an empty quoted string at the end of the command? Or maybe even make this a separate test for specifically that (e.g., TokenizeWindowsCommandLineQuotedLastArgument).

Are there other cases we should test to make sure this doesn't change things? What if the last argument is " or """ or """"? What if there's white space after the last quotation mark? A quick look at the code suggests these might all work with this change, but it looks like they'd hit some other code paths.

[rnk]

Thanks for the fix, I agree with Adrian's feedback. @amccarth, can you take over the review? I will remove myself, thanks.

[amccarth]

I'm happy to see this through.

[neildhar]

Update tests

[neildhar]

Thanks for taking a look @amccarth! I've updated the tests to include one for " as well, I think the other versions (""", """") will trigger the same code paths although I can add them in if that is preferred.

Unfortunately, I've used the wrong linter here and will fix that and update.

[neildhar]

Fix linting

[amccarth]

Thanks for extending the tests. Those will certainly make your fix more robust against regressions.

I'm concerned about the extra complexity added to the state machine and the introduction of an unused API. The new version has more complicated flow control for no obvious benefit, and it seems unrelated to the relatively simple fix this patch started out to be. If there are good reasons for these additional changes, perhaps it would be best to break them into a separate follow-on patch. I'd be happy to review that as well.

llvm/lib/Support/CommandLine.cpp

927

Looks like we have some scope-creep: This patch is now about more than solving the problem with arguments at the end of the line.

I'm not convinced that it's important this be inlined. That's ultimately up to the compiler.

I think the comment about the user entry points doesn't tell us anything that we cannot see in the function signature.

934

I don't understand what I'm supposed to take away from this comment. Either delete it or explain _why_ it's important to do as much work as possible.

I'm not even sure what you mean by "work." It seems this version of the state machine does the same amount of work as the old version. Is this about the fact that the states now have their own internal loops in addition to the outer loop?

944

I'm concerned that the index is advanced here and and in the loop header. I'm not saying it's wrong. It's just harder to reason about state machine behavior when it's a hybrid of a classic loop surrounding state handlers that have their own internal state machines. Now we have a bunch of checks throughout the body to see if we've hit (or exceeded?!) the end. Is there an advantage to this that I'm not seeing?

958

This seems like a behavior change: AddToken will now be called _after_ MarkEOL. Maybe that doesn't matter, but it seems nonsensical to report the delimiter before the token it delimits.

959

Consistent with [[ https://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code

LLVM style ]], the old version used continue to avoid cascades of else if statements. Please follow that pattern here.

1027

Nobody is calling this new function, not even in the tests. Is the intent to replace the original function with this new one to reduce copying? Do we really need the flexibility to parse it both ways, or can we keep things a bit simpler?

1613

Did you intentionally change J to start at 0 rather than 1? This mostly looks like you were just trying to make the style consistent by capitalizing these variable names.

[neildhar]

Hi @amccarth, thanks for taking another look! I'm not sure how those changes render for you, on my screen they don't appear as part of this diff. They were picked up when I rebased, the original diff for those is https://reviews.llvm.org/D79262.

[amccarth]

Ah, I guess the diff was based off the old head rather than the rebased one. Phabricator highlighted all that code as part of this patch.

Sorry about that. I'll have to redirect most of those comments @rnk . That'll be awkward.

Now that Phabricator is showing just seeing fix and test improvements, it looks great.

[neildhar]

No worries, thanks! This is my first patch to LLVM so I do not have commit access, could I trouble you to commit it?

[amccarth]

No problem. I'll land it this afternoon (Pacific time). Thanks!

llvm/lib/Support/CommandLine.cpp

 template class basic_parser<std::string>;
 template class basic_parser<char>;
 
 template class opt<unsigned>;
 template class opt<int>;
 template class opt<std::string>;
 template class opt<char>;
 template class opt<bool>;
-}
-} // end namespace llvm::cl
+} // namespace cl
+} // namespace llvm
 
 // Pin the vtables to this file.
 void GenericOptionValue::anchor() {}
 void OptionValue<boolOrDefault>::anchor() {}
 void OptionValue<std::string>::anchor() {}
 void Option::anchor() {}
 void basic_parser_impl::anchor() {}
 void parser<bool>::anchor() {}

 static inline bool isGrouping(const Option *O) {
   return O->getMiscFlags() & cl::Grouping;
 }
 static inline bool isPrefixedOrGrouping(const Option *O) {
   return isGrouping(O) || O->getFormattingFlag() == cl::Prefix ||
          O->getFormattingFlag() == cl::AlwaysPrefix;
 }
 
-
 namespace {
 
 class PrintArg {
   StringRef ArgName;
   size_t Pad;
+
 public:
-  PrintArg(StringRef ArgName, size_t Pad = DefaultPad) : ArgName(ArgName), Pad(Pad) {}
+  PrintArg(StringRef ArgName, size_t Pad = DefaultPad)
+      : ArgName(ArgName), Pad(Pad) {}
   friend raw_ostream &operator<<(raw_ostream &OS, const PrintArg &);
 };
 
-raw_ostream &operator<<(raw_ostream &OS, const PrintArg& Arg) {
+raw_ostream &operator<<(raw_ostream &OS, const PrintArg &Arg) {
   OS << argPrefix(Arg.ArgName, Arg.Pad) << Arg.ArgName;
   return OS;
 }
 
 class CommandLineParser {
 public:
   // Globals for name and overview of program.  Program name is not a string to
   // avoid static ctor/dtor issues.
   std::string ProgramName;
   StringRef ProgramOverview;
 
   // This collects additional help to be printed.
   std::vector<StringRef> MoreHelp;
 
   // This collects Options added with the cl::DefaultOption flag. Since they can
   // be overridden, they are not added to the appropriate SubCommands until
   // ParseCommandLineOptions actually runs.
-  SmallVector<Option*, 4> DefaultOptions;
+  SmallVector<Option *, 4> DefaultOptions;
 
   // This collects the different option categories that have been registered.
   SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;
 
   // This collects the different subcommands that have been registered.
   SmallPtrSet<SubCommand *, 4> RegisteredSubCommands;
 
   CommandLineParser() : ActiveSubCommand(nullptr) {
if (O->hasArgStr())
       OptionNames.push_back(O->ArgStr);
 
     SubCommand &Sub = *SC;
     auto End = Sub.OptionsMap.end();
     for (auto Name : OptionNames) {
       auto I = Sub.OptionsMap.find(Name);
       if (I != End && I->getValue() == O)
         Sub.OptionsMap.erase(I);
-      }
 
     if (O->getFormattingFlag() == cl::Positional)
       for (auto Opt = Sub.PositionalOpts.begin();
            Opt != Sub.PositionalOpts.end(); ++Opt) {
         if (*Opt == O) {
           Sub.PositionalOpts.erase(Opt);
           break;
         }
void updateArgStr(Option *O, StringRef NewName) {
     }
   }
 
   void printOptionValues();
 
   void registerCategory(OptionCategory *cat) {
     assert(count_if(RegisteredOptionCategories,
                     [cat](const OptionCategory *Category) {
                       return cat->getName() == Category->getName();
                     }) == 0 &&
            "Duplicate option categories");
 
     RegisteredOptionCategories.insert(cat);
   }
 
   void registerSubCommand(SubCommand *sub) {
     assert(count_if(RegisteredSubCommands,
                     [sub](const SubCommand *Sub) {
static bool EatsUnboundedNumberOfValues(const Option *O) {
   return O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
          O->getNumOccurrencesFlag() == cl::OneOrMore;
 }
 
 static bool isWhitespace(char C) {
   return C == ' ' || C == '\t' || C == '\r' || C == '\n';
 }
 
-static bool isWhitespaceOrNull(char C) {
-  return isWhitespace(C) || C == '\0';
-}
+static bool isWhitespaceOrNull(char C) { return isWhitespace(C) || C == '\0'; }
 
 static bool isQuote(char C) { return C == '\"' || C == '\''; }
 
 void cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver,
                                 SmallVectorImpl<const char *> &NewArgv,
                                 bool MarkEOLs) {
   SmallString<128> Token;
   for (size_t I = 0, E = Src.size(); I != E; ++I) {

 }
 
 // Windows treats whitespace, double quotes, and backslashes specially.
 static bool isWindowsSpecialChar(char C) {
   return isWhitespaceOrNull(C) || C == '\\' || C == '\"';
 }
 
 // Windows tokenization implementation. The implementation is designed to be
 // inlined and specialized for the two user entry points.
 static inline void
 tokenizeWindowsCommandLineImpl(StringRef Src, StringSaver &Saver,
                                function_ref<void(StringRef)> AddToken,
                                bool AlwaysCopy, function_ref<void()> MarkEOL) {
   SmallString<128> Token;
 
   // Try to do as much work inside the state machine as possible.
   enum { INIT, UNQUOTED, QUOTED } State = INIT;
   for (size_t I = 0, E = Src.size(); I < E; ++I) {
     switch (State) {
     case INIT: {
       assert(Token.empty() && "token should be empty in initial state");
       // Eat whitespace before a token.
       while (I < E && isWhitespaceOrNull(Src[I])) {
         if (Src[I] == '\n')
           MarkEOL();
         ++I;
       }
       // Stop if this was trailing whitespace.
       if (I >= E)
         break;
       size_t Start = I;
       while (I < E && !isWindowsSpecialChar(Src[I]))
         ++I;
       StringRef NormalChars = Src.slice(Start, I);
       if (I >= E || isWhitespaceOrNull(Src[I])) {
         if (I < E && Src[I] == '\n')
           MarkEOL();
         // No special characters: slice out the substring and start the next
         // token. Copy the string if the caller asks us to.
         AddToken(AlwaysCopy ? Saver.save(NormalChars) : NormalChars);
       } else if (Src[I] == '\"') {
         Token += NormalChars;
         State = QUOTED;
       } else if (Src[I] == '\\') {
         Token += NormalChars;
         I = parseBackslash(Src, I, Token);
         State = UNQUOTED;
       } else {
         llvm_unreachable("unexpected special character");
case QUOTED:
         I = parseBackslash(Src, I, Token);
       } else {
         Token.push_back(Src[I]);
       }
       break;
     }
   }
 
-  if (!Token.empty())
+  if (State == UNQUOTED)
     AddToken(Saver.save(Token.str()));
 }
 
 void cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver,
                                     SmallVectorImpl<const char *> &NewArgv,
                                     bool MarkEOLs) {
   auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Tok.data()); };
   auto OnEOL = [&]() {
     if (MarkEOLs)
       NewArgv.push_back(nullptr);
   };
   tokenizeWindowsCommandLineImpl(Src, Saver, AddToken,
                                  /*AlwaysCopy=*/true, OnEOL);
 }
 
 void cl::TokenizeWindowsCommandLineNoCopy(StringRef Src, StringSaver &Saver,
                                           SmallVectorImpl<StringRef> &NewArgv) {
   auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Tok); };
   auto OnEOL = []() {};
   tokenizeWindowsCommandLineImpl(Src, Saver, AddToken, /*AlwaysCopy=*/false,
                                  OnEOL);
 }
 
 void cl::tokenizeConfigFile(StringRef Source, StringSaver &Saver,

 
 // It is called byte order marker but the UTF-8 BOM is actually not affected
 // by the host system's endianness.
 static bool hasUTF8ByteOrderMark(ArrayRef<char> S) {
   return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');
 }
 
 // FName must be an absolute path.
-static llvm::Error ExpandResponseFile(
-    StringRef FName, StringSaver &Saver, TokenizerCallback Tokenizer,
-    SmallVectorImpl<const char *> &NewArgv, bool MarkEOLs, bool RelativeNames,
+static llvm::Error ExpandResponseFile(StringRef FName, StringSaver &Saver,
+                                      TokenizerCallback Tokenizer,
+                                      SmallVectorImpl<const char *> &NewArgv,
+                                      bool MarkEOLs, bool RelativeNames,
                                       llvm::vfs::FileSystem &FS) {
   assert(sys::path::is_absolute(FName));
   llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
       FS.getBufferForFile(FName);
   if (!MemBufOrErr)
     return llvm::errorCodeToError(MemBufOrErr.getError());
   MemoryBuffer &MemBuf = *MemBufOrErr.get();
   StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize());
 

 ///
 void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
                                  const char *Overview) {
   // Check args.
   assert(progName && "Program name not specified");
   assert(envVar && "Environment variable name missing");
 
   // Get the environment variable they want us to parse options out of.
-  llvm::Optional<std::string> envValue = sys::Process::GetEnv(StringRef(envVar));
+  llvm::Optional<std::string> envValue =
+      sys::Process::GetEnv(StringRef(envVar));
   if (!envValue)
     return;
 
   // Get program's "name", which we wouldn't know without the caller
   // telling us.
   SmallVector<const char *, 20> newArgv;
   BumpPtrAllocator A;
   StringSaver Saver(A);
bool CommandLineParser::ParseCommandLineOptions(int argc,
                                                 bool LongOptionsUseDoubleDash) {
   assert(hasOptions() && "No options specified!");
 
   // Expand response files.
   SmallVector<const char *, 20> newArgv(argv, argv + argc);
   BumpPtrAllocator A;
   StringSaver Saver(A);
   ExpandResponseFiles(Saver,
-         Triple(sys::getProcessTriple()).isOSWindows() ?
-         cl::TokenizeWindowsCommandLine : cl::TokenizeGNUCommandLine,
+                      Triple(sys::getProcessTriple()).isOSWindows()
+                          ? cl::TokenizeWindowsCommandLine
+                          : cl::TokenizeGNUCommandLine,
                       newArgv);
   argv = &newArgv[0];
   argc = static_cast<int>(newArgv.size());
 
   // Copy the program name into ProgName, making sure not to overflow it.
   ProgramName = std::string(sys::path::filename(StringRef(argv[0])));
 
   ProgramOverview = Overview;
   bool IgnoreErrors = Errs;
bool CommandLineParser::ParseCommandLineOptions(int argc,
   GlobalParser->ActiveSubCommand = ChosenSubCommand;
 
   assert(ChosenSubCommand);
   auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;
   auto &PositionalOpts = ChosenSubCommand->PositionalOpts;
   auto &SinkOpts = ChosenSubCommand->SinkOpts;
   auto &OptionsMap = ChosenSubCommand->OptionsMap;
 
-  for (auto O: DefaultOptions) {
+  for (auto O : DefaultOptions) {
     addOption(O, true);
   }
 
   if (ConsumeAfterOpt) {
     assert(PositionalOpts.size() > 0 &&
            "Cannot specify cl::ConsumeAfter without a positional argument!");
   }
   if (!PositionalOpts.empty()) {
for (int i = FirstArg; i < argc; ++i) {
     }
 
     // If this is a named positional argument, just remember that it is the
     // active one...
     if (Handler->getFormattingFlag() == cl::Positional) {
       if ((Handler->getMiscFlags() & PositionalEatsArgs) && !Value.empty()) {
         Handler->error("This argument does not take a value.\n"
                        "\tInstead, it consumes any positional arguments until "
-                       "the next recognized option.", *Errs);
+                       "the next recognized option.",
+                       *Errs);
         ErrorParsing = true;
       }
       ActivePositionalArg = Handler;
-    }
-    else
+    } else
       ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);
   }
 
   // Check and handle positional arguments now...
   if (NumPositionalRequired > PositionalVals.size()) {
-      *Errs << ProgramName
-             << ": Not enough positional command line arguments specified!\n"
-             << "Must specify at least " << NumPositionalRequired
-             << " positional argument" << (NumPositionalRequired > 1 ? "s" : "")
-             << ": See: " << argv[0] << " --help\n";
 
     ErrorParsing = true;
   } else if (!HasUnlimitedPositionals &&
              PositionalVals.size() > PositionalOpts.size()) {
     *Errs << ProgramName << ": Too many positional arguments specified!\n"
           << "Can specify at most " << PositionalOpts.size()
           << " positional arguments: See: " << argv[0] << " --help\n";
     ErrorParsing = true;
for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {
           llvm_unreachable("Internal error, unexpected NumOccurrences flag in "
                            "positional argument processing!");
         }
       }
     }
   } else {
     assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size());
     unsigned ValNo = 0;
     for (size_t J = 0, E = PositionalOpts.size(); J != E; ++J)
       if (RequiresValue(PositionalOpts[J])) {
         ErrorParsing |= ProvidePositionalOption(PositionalOpts[J],
                                                 PositionalVals[ValNo].first,
                                                 PositionalVals[ValNo].second);
         ValNo++;
       }
 
     // Handle the case where there is just one positional option, and it's
static StringRef getValueStr(const Option &O, StringRef DefaultMsg) {
   return O.ValueStr;
 }
 
 //===----------------------------------------------------------------------===//
 // cl::alias class implementation
 //
 
 // Return the width of the option tag for printing...
-size_t alias::getOptionWidth() const {
-  return argPlusPrefixesSize(ArgStr);
-}
+size_t alias::getOptionWidth() const { return argPlusPrefixesSize(ArgStr); }
 
 void Option::printHelpStr(StringRef HelpStr, size_t Indent,
                           size_t FirstLineIndentedBy) {
   assert(Indent >= FirstLineIndentedBy);
   std::pair<StringRef, StringRef> Split = HelpStr.split('\n');
   outs().indent(Indent - FirstLineIndentedBy)
       << ArgHelpPrefix << Split.first << "\n";
   while (!Split.second.empty()) {
static bool shouldPrintOption(StringRef Name, StringRef Description,
                               const Option &O) {
   return O.getValueExpectedFlag() != ValueOptional || !Name.empty() ||
          !Description.empty();
 }
 
 // Return the width of the option tag for printing...
 size_t generic_parser_base::getOptionWidth(const Option &O) const {
   if (O.hasArgStr()) {
-    size_t Size =
-        argPlusPrefixesSize(O.ArgStr) + EqValue.size();
+    size_t Size = argPlusPrefixesSize(O.ArgStr) + EqValue.size();
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
       StringRef Name = getOption(i);
       if (!shouldPrintOption(Name, getDescription(i), O))
         continue;
       size_t NameSize = Name.empty() ? EmptyOption.size() : Name.size();
       Size = std::max(Size, NameSize + OptionPrefixesSize);
     }
     return Size;
if (O.getValueExpectedFlag() == ValueOptional) {
                                argPlusPrefixesSize(O.ArgStr));
           break;
         }
       }
     }
 
     outs() << PrintArg(O.ArgStr) << EqValue;
     Option::printHelpStr(O.HelpStr, GlobalWidth,
-                         EqValue.size() +
-                             argPlusPrefixesSize(O.ArgStr));
+                         EqValue.size() + argPlusPrefixesSize(O.ArgStr));
     for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
       StringRef OptionName = getOption(i);
       StringRef Description = getDescription(i);
       if (!shouldPrintOption(OptionName, Description, O))
         continue;
       assert(GlobalWidth >= OptionName.size() + OptionPrefixesSize);
       size_t NumSpaces = GlobalWidth - OptionName.size() - OptionPrefixesSize;
       outs() << OptionPrefix << OptionName;

 
 static VersionPrinterTy OverrideVersionPrinter = nullptr;
 
 static std::vector<VersionPrinterTy> *ExtraVersionPrinters = nullptr;
 
 #if defined(__GNUC__)
 // GCC and GCC-compatible compilers define __OPTIMIZE__ when optimizations are
 // enabled.
-# if defined(__OPTIMIZE__)
-#  define LLVM_IS_DEBUG_BUILD 0
-# else
-#  define LLVM_IS_DEBUG_BUILD 1
-# endif
+#if defined(__OPTIMIZE__)
+#define LLVM_IS_DEBUG_BUILD 0
+#else
+#define LLVM_IS_DEBUG_BUILD 1
+#endif
 #elif defined(_MSC_VER)
 // MSVC doesn't have a predefined macro indicating if optimizations are enabled.
 // Use _DEBUG instead. This macro actually corresponds to the choice between
 // debug and release CRTs, but it is a reasonable proxy.
-# if defined(_DEBUG)
-#  define LLVM_IS_DEBUG_BUILD 1
-# else
-#  define LLVM_IS_DEBUG_BUILD 0
-# endif
+#if defined(_DEBUG)
+#define LLVM_IS_DEBUG_BUILD 1
+#else
+#define LLVM_IS_DEBUG_BUILD 0
+#endif
 #else
 // Otherwise, for an unknown compiler, assume this is an optimized build.
-# define LLVM_IS_DEBUG_BUILD 0
+#define LLVM_IS_DEBUG_BUILD 0
 #endif
 
 namespace {
 class VersionPrinter {
 public:
   void print() {
     raw_ostream &OS = outs();
 #ifdef PACKAGE_VENDOR
else if (Hidden && !Categorized)
     UncategorizedHiddenPrinter.printHelp();
   else
     CategorizedHiddenPrinter.printHelp();
 }
 
 /// Utility function for printing version number.
 void cl::PrintVersionMessage() { VersionPrinterInstance.print(); }
 
-void cl::SetVersionPrinter(VersionPrinterTy func) { OverrideVersionPrinter = func; }
+void cl::SetVersionPrinter(VersionPrinterTy func) {
+  OverrideVersionPrinter = func;
+}
 
 void cl::AddExtraVersionPrinter(VersionPrinterTy func) {
   if (!ExtraVersionPrinters)
     ExtraVersionPrinters = new std::vector<VersionPrinterTy>;
 
   ExtraVersionPrinters->push_back(func);
 }
 
 StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) {
   auto &Subs = GlobalParser->RegisteredSubCommands;
   (void)Subs;
   assert(is_contained(Subs, &Sub));
   return Sub.OptionsMap;
 }
 
 iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator>
 cl::getRegisteredSubcommands() {
   return GlobalParser->getRegisteredSubcommands();
 }
 
 void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) {
   for (auto &I : Sub.OptionsMap) {
     for (auto &Cat : I.second->Categories) {
-      if (Cat != &Category &&
-          Cat != &GenericCategory)
+      if (Cat != &Category && Cat != &GenericCategory)
         I.second->setHiddenFlag(cl::ReallyHidden);
     }
   }
 }
 
 void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories,
                               SubCommand &Sub) {
   for (auto &I : Sub.OptionsMap) {

llvm/unittests/Support/CommandLineTest.cpp

 
 namespace {
 
 MATCHER(StringEquality, "Checks if two char* are equal as strings") {
   return std::string(std::get<0>(arg)) == std::string(std::get<1>(arg));
 }
 
 class TempEnvVar {
- public:
-  TempEnvVar(const char *name, const char *value)
-      : name(name) {
+  TempEnvVar(const char *name, const char *value) : name(name) {
     const char *old_value = getenv(name);
     EXPECT_EQ(nullptr, old_value) << old_value;
 #if HAVE_SETENV
     setenv(name, value, true);
 #else
-#   define SKIP_ENVIRONMENT_TESTS
+#define SKIP_ENVIRONMENT_TESTS
 #endif
   }
 
   ~TempEnvVar() {
 #if HAVE_SETENV
     // Assume setenv and unsetenv come together.
     unsetenv(name);
 #else
     (void)name; // Suppress -Wunused-private-field.
 #endif
   }
 
- private:
   const char *const name;
 };
 
 template <typename T, typename Base = cl::opt<T>>
 class StackOption : public Base {
 public:
   template <class... Ts>
   explicit StackOption(Ts &&... Ms) : Base(std::forward<Ts>(Ms)...) {}
 
   ~StackOption() override { this->removeArgument(); }
 
   template <class DT> StackOption<T> &operator=(const DT &V) {
     Base::operator=(V);
     return *this;
   }
 };
 
 class StackSubCommand : public cl::SubCommand {
 public:
-  StackSubCommand(StringRef Name,
-                  StringRef Description = StringRef())
+  StackSubCommand(StringRef Name, StringRef Description = StringRef())
       : SubCommand(Name, Description) {}
 
   StackSubCommand() : SubCommand() {}
 
   ~StackSubCommand() { unregisterSubCommand(); }
 };
 
-
 cl::OptionCategory TestCategory("Test Options", "Description");
 TEST(CommandLineTest, ModifyExisitingOption) {
   StackOption<int> TestOption("test-option", cl::desc("old description"));
 
   static const char Description[] = "New description";
   static const char ArgString[] = "new-test-option";
   static const char ValueString[] = "Integer";
 
   StringMap<cl::Option *> &Map =
       cl::getRegisteredOptions(*cl::TopLevelSubCommand);
 
-  ASSERT_TRUE(Map.count("test-option") == 1) <<
-    "Could not find option in map.";
+  ASSERT_TRUE(Map.count("test-option") == 1) << "Could not find option in map.";
 
   cl::Option *Retrieved = Map["test-option"];
   ASSERT_EQ(&TestOption, Retrieved) << "Retrieved wrong option.";
 
   ASSERT_NE(Retrieved->Categories.end(),
             find_if(Retrieved->Categories,
                     [&](const llvm::cl::OptionCategory *Cat) {
                       return Cat == &cl::GeneralCategory;
TEST(CommandLineTest, ModifyExisitingOption) {
   ASSERT_STREQ(ArgString, Retrieved->ArgStr.data())
       << "Failed to modify option's Argument string.";
 
   Retrieved->setValueStr(ValueString);
   ASSERT_STREQ(Retrieved->ValueStr.data(), ValueString)
       << "Failed to modify option's Value string.";
 
   Retrieved->setHiddenFlag(cl::Hidden);
-  ASSERT_EQ(cl::Hidden, TestOption.getOptionHiddenFlag()) <<
-    "Failed to modify option's hidden flag.";
+  ASSERT_EQ(cl::Hidden, TestOption.getOptionHiddenFlag())
+      << "Failed to modify option's hidden flag.";
 }
 #ifndef SKIP_ENVIRONMENT_TESTS
 
 const char test_env_var[] = "LLVM_TEST_COMMAND_LINE_FLAGS";
 
 cl::opt<std::string> EnvironmentTestOption("env-test-opt");
 TEST(CommandLineTest, ParseEnvironment) {
   TempEnvVar TEV(test_env_var, "-env-test-opt=hello");
TEST(CommandLineTest, ParseEnvironmentToLocalVar) {
   // Put cl::opt on stack to check for proper initialization of fields.
   StackOption<std::string> EnvironmentTestOptionLocal("env-test-opt-local");
   TempEnvVar TEV(test_env_var, "-env-test-opt-local=hello-local");
   EXPECT_EQ("", EnvironmentTestOptionLocal);
   cl::ParseEnvironmentOptions("CommandLineTest", test_env_var);
   EXPECT_EQ("hello-local", EnvironmentTestOptionLocal);
 }
 
-#endif  // SKIP_ENVIRONMENT_TESTS
+#endif // SKIP_ENVIRONMENT_TESTS
 
 TEST(CommandLineTest, UseOptionCategory) {
   StackOption<int> TestOption2("test-option", cl::cat(TestCategory));
 
   ASSERT_NE(TestOption2.Categories.end(),
             find_if(TestOption2.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &TestCategory;
-                         }))
       << "Failed to assign Option Category.";
 }
 
 TEST(CommandLineTest, UseMultipleCategories) {
   StackOption<int> TestOption2("test-option2", cl::cat(TestCategory),
                                cl::cat(cl::GeneralCategory),
                                cl::cat(cl::GeneralCategory));
 
   // Make sure cl::GeneralCategory wasn't added twice.
   ASSERT_EQ(TestOption2.Categories.size(), 2U);
 
   ASSERT_NE(TestOption2.Categories.end(),
             find_if(TestOption2.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &TestCategory;
-                         }))
       << "Failed to assign Option Category.";
   ASSERT_NE(TestOption2.Categories.end(),
             find_if(TestOption2.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &cl::GeneralCategory;
-                         }))
       << "Failed to assign General Category.";
 
   cl::OptionCategory AnotherCategory("Additional test Options", "Description");
   StackOption<int> TestOption("test-option", cl::cat(TestCategory),
                               cl::cat(AnotherCategory));
   ASSERT_EQ(TestOption.Categories.end(),
             find_if(TestOption.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &cl::GeneralCategory;
-                         }))
       << "Failed to remove General Category.";
   ASSERT_NE(TestOption.Categories.end(),
             find_if(TestOption.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &TestCategory;
-                         }))
       << "Failed to assign Option Category.";
   ASSERT_NE(TestOption.Categories.end(),
             find_if(TestOption.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &AnotherCategory;
-                         }))
       << "Failed to assign Another Category.";
 }
 
 typedef void ParserFunction(StringRef Source, StringSaver &Saver,
                             SmallVectorImpl<const char *> &NewArgv,
                             bool MarkEOLs);
 
 void testCommandLineTokenizer(ParserFunction *parse, StringRef Input,
for (unsigned I = 0, E = Actual.size(); I != E; ++I) {
     }
   }
 }
 
 TEST(CommandLineTest, TokenizeGNUCommandLine) {
   const char Input[] =
       "foo\\ bar \"foo bar\" \'foo bar\' 'foo\\\\bar' -DFOO=bar\\(\\) "
       "foo\"bar\"baz C:\\\\src\\\\foo.cpp \"C:\\src\\foo.cpp\"";
-  const char *const Output[] = {
-      "foo bar",     "foo bar",   "foo bar",          "foo\\bar",
-      "-DFOO=bar()", "foobarbaz", "C:\\src\\foo.cpp", "C:srcfoo.cpp"};
+  const char *const Output[] = {"foo bar",          "foo bar",     "foo bar",
+                                "foo\\bar",         "-DFOO=bar()", "foobarbaz",
+                                "C:\\src\\foo.cpp", "C:srcfoo.cpp"};
   testCommandLineTokenizer(cl::TokenizeGNUCommandLine, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeWindowsCommandLine1) {
-  const char Input[] = "a\\b c\\\\d e\\\\\"f g\" h\\\"i j\\\\\\\"k \"lmn\" o pqr "
-                      "\"st \\\"u\" \\v";
-  const char *const Output[] = { "a\\b", "c\\\\d", "e\\f g", "h\"i", "j\\\"k",
-                                 "lmn", "o", "pqr", "st \"u", "\\v" };
+  const char Input[] =
+      R"(a\b c\\d e\\"f g" h\"i j\\\"k "lmn" o pqr "st \"u" \v)";
+  const char *const Output[] = {"a\\b", "c\\\\d", "e\\f g", "h\"i",   "j\\\"k",
+                                "lmn",  "o",      "pqr",    "st \"u", "\\v"};
   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeWindowsCommandLine2) {
   const char Input[] = "clang -c -DFOO=\"\"\"ABC\"\"\" x.cpp";
-  const char *const Output[] = { "clang", "-c", "-DFOO=\"ABC\"", "x.cpp"};
+  const char *const Output[] = {"clang", "-c", "-DFOO=\"ABC\"", "x.cpp"};
   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input, Output,
                            array_lengthof(Output));
 }
 
+TEST(CommandLineTest, TokenizeWindowsCommandLineQuotedLastArgument) {
+  const char Input1[] = R"(a b c d "")";
+  const char *const Output1[] = {"a", "b", "c", "d", ""};
+  testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input1, Output1,
+                           array_lengthof(Output1));
+  const char Input2[] = R"(a b c d ")";
+  const char *const Output2[] = {"a", "b", "c", "d"};
+  testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input2, Output2,
+                           array_lengthof(Output2));
+}
+
 TEST(CommandLineTest, TokenizeConfigFile1) {
   const char *Input = "\\";
-  const char *const Output[] = { "\\" };
+  const char *const Output[] = {"\\"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile2) {
   const char *Input = "\\abc";
-  const char *const Output[] = { "abc" };
+  const char *const Output[] = {"abc"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile3) {
   const char *Input = "abc\\";
-  const char *const Output[] = { "abc\\" };
+  const char *const Output[] = {"abc\\"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile4) {
   const char *Input = "abc\\\n123";
-  const char *const Output[] = { "abc123" };
+  const char *const Output[] = {"abc123"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile5) {
   const char *Input = "abc\\\r\n123";
-  const char *const Output[] = { "abc123" };
+  const char *const Output[] = {"abc123"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile6) {
   const char *Input = "abc\\\n";
-  const char *const Output[] = { "abc" };
+  const char *const Output[] = {"abc"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile7) {
   const char *Input = "abc\\\r\n";
-  const char *const Output[] = { "abc" };
+  const char *const Output[] = {"abc"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile8) {
   SmallVector<const char *, 0> Actual;
   BumpPtrAllocator A;
   StringSaver Saver(A);
   cl::tokenizeConfigFile("\\\n", Saver, Actual, /*MarkEOLs=*/false);
   EXPECT_TRUE(Actual.empty());
 }
 
 TEST(CommandLineTest, TokenizeConfigFile9) {
   SmallVector<const char *, 0> Actual;
   BumpPtrAllocator A;
   StringSaver Saver(A);
   cl::tokenizeConfigFile("\\\r\n", Saver, Actual, /*MarkEOLs=*/false);
   EXPECT_TRUE(Actual.empty());
 }
 
 TEST(CommandLineTest, TokenizeConfigFile10) {
   const char *Input = "\\\nabc";
-  const char *const Output[] = { "abc" };
+  const char *const Output[] = {"abc"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeConfigFile11) {
   const char *Input = "\\\r\nabc";
-  const char *const Output[] = { "abc" };
+  const char *const Output[] = {"abc"};
   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, AliasesWithArguments) {
   static const size_t ARGC = 3;
-  const char *const Inputs[][ARGC] = {
-    { "-tool", "-actual=x", "-extra" },
-    { "-tool", "-actual", "x" },
-    { "-tool", "-alias=x", "-extra" },
-    { "-tool", "-alias", "x" }
-  };
+  const char *const Inputs[][ARGC] = {{"-tool", "-actual=x", "-extra"},
+                                      {"-tool", "-actual", "x"},
+                                      {"-tool", "-alias=x", "-extra"},
+                                      {"-tool", "-alias", "x"}};
 
   for (size_t i = 0, e = array_lengthof(Inputs); i < e; ++i) {
     StackOption<std::string> Actual("actual");
     StackOption<bool> Extra("extra");
     StackOption<std::string> Input(cl::Positional);
 
     cl::alias Alias("alias", llvm::cl::aliasopt(Actual));
 
void testAliasRequired(int argc, const char *const *argv) {
   cl::ParseCommandLineOptions(argc, argv);
   EXPECT_EQ("x", Option);
   EXPECT_EQ(1, Option.getNumOccurrences());
 
   Alias.removeArgument();
 }
 
 TEST(CommandLineTest, AliasRequired) {
-  const char *opts1[] = { "-tool", "-option=x" };
-  const char *opts2[] = { "-tool", "-o", "x" };
+  const char *opts1[] = {"-tool", "-option=x"};
+  const char *opts2[] = {"-tool", "-o", "x"};
   testAliasRequired(array_lengthof(opts1), opts1);
   testAliasRequired(array_lengthof(opts2), opts2);
 }
 
 TEST(CommandLineTest, HideUnrelatedOptions) {
   StackOption<int> TestOption1("hide-option-1");
   StackOption<int> TestOption2("hide-option-2", cl::cat(TestCategory));
 
TEST(CommandLineTest, DefaultOptions) {
   for (auto *S : cl::getRegisteredSubcommands()) {
     if (*S) {
       EXPECT_EQ("sc1", S->getName());
     }
   }
 
   cl::ResetAllOptionOccurrences();
 
-  const char *args2[] = {"prog", "sc2", "-b", "args2 bar string",
-                         "-f", "-foo", "foo string"};
+  const char *args2[] = {"prog", "sc2",  "-b",        "args2 bar string",
+                         "-f",   "-foo", "foo string"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(sizeof(args2) / sizeof(char *), args2,
                                           StringRef(), &llvm::nulls()));
   EXPECT_TRUE(Bar == "args2 bar string");
   EXPECT_TRUE(Foo);
   EXPECT_FALSE(SC1_B);
   EXPECT_TRUE(SC2_Foo == "foo string");
   for (auto *S : cl::getRegisteredSubcommands()) {
     if (*S) {
TEST(CommandLineTest, ResponseFileWindows) {
 
   StackOption<std::string, cl::list<std::string>> InputFilenames(
       cl::Positional, cl::desc("<input files>"), cl::ZeroOrMore);
   StackOption<bool> TopLevelOpt("top-level", cl::init(false));
 
   // Create response file.
   int FileDescriptor;
   SmallString<64> TempPath;
-  std::error_code EC =
-      llvm::sys::fs::createTemporaryFile("resp-", ".txt", FileDescriptor, TempPath);
+  std::error_code EC = llvm::sys::fs::createTemporaryFile(
+      "resp-", ".txt", FileDescriptor, TempPath);
   EXPECT_TRUE(!EC);
 
   std::ofstream RspFile(TempPath.c_str());
   EXPECT_TRUE(RspFile.is_open());
   RspFile << "-top-level\npath\\dir\\file1\npath/dir/file2";
   RspFile.close();
 
   llvm::SmallString<128> RspOpt;
#else
   const char *TestRoot = "/";
 #endif
   FS.setCurrentWorkingDirectory(TestRoot);
 
   StringRef ResponseFilePath = "test.rsp";
 
   std::string ResponseFileContents;
   raw_string_ostream ResponseFile(ResponseFileContents);
-  ResponseFile << "-foo" << "\n";
-  ResponseFile << "-bar" << "\n";
+  ResponseFile << "-foo"
+               << "\n";
+  ResponseFile << "-bar"
+               << "\n";
   FS.addFile(ResponseFilePath, 0,
              MemoryBuffer::getMemBuffer(ResponseFile.str()));
 
   // Ensure we expand rsp files after lots of non-rsp arguments starting with @.
   constexpr size_t NON_RSP_AT_ARGS = 64;
   SmallVector<const char *, 4> Argv = {"test/test"};
   Argv.append(NON_RSP_AT_ARGS, "@non_rsp_at_arg");
   std::string ResponseFileRef = ("@" + ResponseFilePath).str();
TEST(CommandLineTest, SetDefautValue) {
   StackOption<std::string> Opt1("opt1", cl::init("true"));
   StackOption<bool> Opt2("opt2", cl::init(true));
   cl::alias Alias("alias", llvm::cl::aliasopt(Opt2));
   StackOption<int> Opt3("opt3", cl::init(3));
 
   const char *args[] = {"prog", "-opt1=false", "-opt2", "-opt3"};
 
   EXPECT_TRUE(
       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 
   EXPECT_TRUE(Opt1 == "false");
   EXPECT_TRUE(Opt2);
   EXPECT_TRUE(Opt3 == 3);
 
   Opt2 = false;
   Opt3 = 1;
 
TEST(CommandLineTest, PositionalEatArgsError) {
   const char *args2[] = {"prog", "-positional-eat-args=XXXX", "-foo"};
   const char *args3[] = {"prog", "-positional-eat-args", "-foo"};
   const char *args4[] = {"prog", "-positional-eat-args",
                          "-foo", "-positional-eat-args2",
                          "-bar", "foo"};
 
   std::string Errs;
   raw_string_ostream OS(Errs);
-  EXPECT_FALSE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS)); OS.flush();
-  EXPECT_FALSE(Errs.empty()); Errs.clear();
-  EXPECT_FALSE(cl::ParseCommandLineOptions(3, args2, StringRef(), &OS)); OS.flush();
-  EXPECT_FALSE(Errs.empty()); Errs.clear();
-  EXPECT_TRUE(cl::ParseCommandLineOptions(3, args3, StringRef(), &OS)); OS.flush();
-  EXPECT_TRUE(Errs.empty()); Errs.clear();
+  EXPECT_FALSE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS));
+  OS.flush();
+  EXPECT_FALSE(Errs.empty());
+  Errs.clear();
+  EXPECT_FALSE(cl::ParseCommandLineOptions(3, args2, StringRef(), &OS));
+  OS.flush();
+  EXPECT_FALSE(Errs.empty());
+  Errs.clear();
+  EXPECT_TRUE(cl::ParseCommandLineOptions(3, args3, StringRef(), &OS));
+  OS.flush();
+  EXPECT_TRUE(Errs.empty());
+  Errs.clear();
 
   cl::ResetAllOptionOccurrences();
-  EXPECT_TRUE(cl::ParseCommandLineOptions(6, args4, StringRef(), &OS)); OS.flush();
+  EXPECT_TRUE(cl::ParseCommandLineOptions(6, args4, StringRef(), &OS));
+  OS.flush();
   EXPECT_TRUE(PosEatArgs.size() == 1);
   EXPECT_TRUE(PosEatArgs2.size() == 2);
   EXPECT_TRUE(Errs.empty());
 }
 
 #ifdef _WIN32
 TEST(CommandLineTest, GetCommandLineArguments) {
   int argc = __argc;
   char **argv = __argv;
 
   // GetCommandLineArguments is called in InitLLVM.
   llvm::InitLLVM X(argc, argv);
 
   EXPECT_EQ(llvm::sys::path::is_absolute(argv[0]),
             llvm::sys::path::is_absolute(__argv[0]));
 
-  EXPECT_TRUE(llvm::sys::path::filename(argv[0])
-              .equals_lower("supporttests.exe"))
+  EXPECT_TRUE(
+      llvm::sys::path::filename(argv[0]).equals_lower("supporttests.exe"))
       << "Filename of test executable is "
       << llvm::sys::path::filename(argv[0]);
 }
 #endif
 
 class OutputRedirector {
 public:
   OutputRedirector(int RedirectFD)
struct AutoDeleteFile {
   }
 };
 
 class PrintOptionInfoTest : public ::testing::Test {
 public:
   // Return std::string because the output of a failing EXPECT check is
   // unreadable for StringRef. It also avoids any lifetime issues.
   template <typename... Ts> std::string runTest(Ts... OptionAttributes) {
-    outs().flush();  // flush any output from previous tests
+    outs().flush(); // flush any output from previous tests
     AutoDeleteFile File;
     {
       OutputRedirector Stdout(fileno(stdout));
       if (!Stdout.Valid)
         return "";
       File.FilePath = Stdout.FilePath;
 
       StackOption<OptionValue> TestOption(Opt, cl::desc(HelpText),
TEST(CommandLineTest, LongOptions) {
   const char *args2[] = {"prog", "-a", "--ab", "val1"};
   const char *args3[] = {"prog", "-ab", "--ab", "val1"};
 
   //
   // The following tests treat `-` and `--` the same, and always match the
   // longest string.
   //
 
-  EXPECT_TRUE(
-      cl::ParseCommandLineOptions(4, args1, StringRef(), &OS)); OS.flush();
+  EXPECT_TRUE(cl::ParseCommandLineOptions(4, args1, StringRef(), &OS));
+  OS.flush();
   EXPECT_TRUE(OptA);
   EXPECT_FALSE(OptBLong);
   EXPECT_STREQ("val1", OptAB.c_str());
-  EXPECT_TRUE(Errs.empty()); Errs.clear();
+  EXPECT_TRUE(Errs.empty());
+  Errs.clear();
   cl::ResetAllOptionOccurrences();
 
-  EXPECT_TRUE(
-      cl::ParseCommandLineOptions(4, args2, StringRef(), &OS)); OS.flush();
+  EXPECT_TRUE(cl::ParseCommandLineOptions(4, args2, StringRef(), &OS));
+  OS.flush();
   EXPECT_TRUE(OptA);
   EXPECT_FALSE(OptBLong);
   EXPECT_STREQ("val1", OptAB.c_str());
-  EXPECT_TRUE(Errs.empty()); Errs.clear();
+  EXPECT_TRUE(Errs.empty());
+  Errs.clear();
   cl::ResetAllOptionOccurrences();
 
   // Fails because `-ab` and `--ab` are treated the same and appear more than
   // once.  Also, `val1` is unexpected.
-  EXPECT_FALSE(
-      cl::ParseCommandLineOptions(4, args3, StringRef(), &OS)); OS.flush();
-  outs()<< Errs << "\n";
-  EXPECT_FALSE(Errs.empty()); Errs.clear();
+  EXPECT_FALSE(cl::ParseCommandLineOptions(4, args3, StringRef(), &OS));
+  OS.flush();
+  outs() << Errs << "\n";
+  EXPECT_FALSE(Errs.empty());
+  Errs.clear();
   cl::ResetAllOptionOccurrences();
 
   //
   // The following tests treat `-` and `--` differently, with `-` for short, and
   // `--` for long options.
   //
 
   // Fails because `-ab` is treated as `-a -b`, so `-a` is seen twice, and
   // `val1` is unexpected.
-  EXPECT_FALSE(cl::ParseCommandLineOptions(4, args1, StringRef(),
-                                           &OS, nullptr, true)); OS.flush();
-  EXPECT_FALSE(Errs.empty()); Errs.clear();
+  EXPECT_FALSE(
+      cl::ParseCommandLineOptions(4, args1, StringRef(), &OS, nullptr, true));
+  OS.flush();
+  EXPECT_FALSE(Errs.empty());
+  Errs.clear();
   cl::ResetAllOptionOccurrences();
 
   // Works because `-a` is treated differently than `--ab`.
-  EXPECT_TRUE(cl::ParseCommandLineOptions(4, args2, StringRef(),
-                                           &OS, nullptr, true)); OS.flush();
-  EXPECT_TRUE(Errs.empty()); Errs.clear();
+  EXPECT_TRUE(
+      cl::ParseCommandLineOptions(4, args2, StringRef(), &OS, nullptr, true));
+  OS.flush();
+  EXPECT_TRUE(Errs.empty());
+  Errs.clear();
   cl::ResetAllOptionOccurrences();
 
   // Works because `-ab` is treated as `-a -b`, and `--ab` is a long option.
-  EXPECT_TRUE(cl::ParseCommandLineOptions(4, args3, StringRef(),
-                                           &OS, nullptr, true));
+  EXPECT_TRUE(
+      cl::ParseCommandLineOptions(4, args3, StringRef(), &OS, nullptr, true));
   EXPECT_TRUE(OptA);
   EXPECT_TRUE(OptBLong);
   EXPECT_STREQ("val1", OptAB.c_str());
   OS.flush();
-  EXPECT_TRUE(Errs.empty()); Errs.clear();
+  EXPECT_TRUE(Errs.empty());
+  Errs.clear();
   cl::ResetAllOptionOccurrences();
 }
 
 TEST(CommandLineTest, OptionErrorMessage) {
   // When there is an error, we expect some error message like:
   //   prog: for the -a option: [...]
   //
   // Test whether the "for the -a option"-part is correctly formatted.
TEST(CommandLineTest, OptionErrorMessageSuggest) {
 
   cl::ResetAllOptionOccurrences();
 }
 
 TEST(CommandLineTest, Callback) {
   cl::ResetCommandLineParser();
 
   StackOption<bool> OptA("a", cl::desc("option a"));
-  StackOption<bool> OptB(
-      "b", cl::desc("option b -- This option turns on option a"),
+  StackOption<bool> OptB("b",
+                         cl::desc("option b -- This option turns on option a"),
                          cl::callback([&](const bool &) { OptA = true; }));
   StackOption<bool> OptC(
       "c", cl::desc("option c -- This option turns on options a and b"),
       cl::callback([&](const bool &) { OptB = true; }));
   StackOption<std::string, cl::list<std::string>> List(
       "list",
       cl::desc("option list -- This option turns on options a, b, and c when "
                "'foo' is included in list"),
-      cl::CommaSeparated,
-      cl::callback([&](const std::string &Str) {
+      cl::CommaSeparated, cl::callback([&](const std::string &Str) {
         if (Str == "foo")
           OptC = true;
       }));
 
   const char *args1[] = {"prog", "-a"};
   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args1));
   EXPECT_TRUE(OptA);
   EXPECT_FALSE(OptB);
TEST(CommandLineTest, Callback) {
   EXPECT_FALSE(OptB);
   EXPECT_FALSE(OptC);
   EXPECT_TRUE(List.size() == 1);
 
   cl::ResetAllOptionOccurrences();
 }
 
 enum Enum { Val1, Val2 };
-static cl::bits<Enum> ExampleBits(
-    cl::desc("An example cl::bits to ensure it compiles"),
-    cl::values(
-      clEnumValN(Val1, "bits-val1", "The Val1 value"),
+static cl::bits<Enum>
+    ExampleBits(cl::desc("An example cl::bits to ensure it compiles"),
+                cl::values(clEnumValN(Val1, "bits-val1", "The Val1 value"),
                            clEnumValN(Val1, "bits-val2", "The Val2 value")));
 
 TEST(CommandLineTest, ConsumeAfterOnePositional) {
   cl::ResetCommandLineParser();
 
   // input [args]
   StackOption<std::string, cl::opt<std::string>> Input(cl::Positional,
                                                        cl::Required);
   StackOption<std::string, cl::list<std::string>> ExtraArgs(cl::ConsumeAfter);