diff --git a/llvm/lib/Support/CommandLine.cpp b/llvm/lib/Support/CommandLine.cpp
--- a/llvm/lib/Support/CommandLine.cpp
+++ b/llvm/lib/Support/CommandLine.cpp
@@ -72,8 +72,8 @@
 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() {}
@@ -127,18 +127,19 @@
          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;
 }
@@ -156,7 +157,7 @@
   // 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;
@@ -277,7 +278,7 @@
       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();
@@ -356,8 +357,8 @@
   void registerCategory(OptionCategory *cat) {
     assert(count_if(RegisteredOptionCategories,
                     [cat](const OptionCategory *Category) {
-             return cat->getName() == Category->getName();
-           }) == 0 &&
+                      return cat->getName() == Category->getName();
+                    }) == 0 &&
            "Duplicate option categories");
 
     RegisteredOptionCategories.insert(cat);
@@ -814,9 +815,7 @@
   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 == '\''; }
 
@@ -1009,7 +1008,7 @@
     }
   }
 
-  if (!Token.empty())
+  if (State == UNQUOTED)
     AddToken(Saver.save(Token.str()));
 }
 
@@ -1079,10 +1078,11 @@
 }
 
 // FName must be an absolute path.
-static llvm::Error ExpandResponseFile(
-    StringRef FName, StringSaver &Saver, TokenizerCallback Tokenizer,
-    SmallVectorImpl<const char *> &NewArgv, bool MarkEOLs, bool RelativeNames,
-    llvm::vfs::FileSystem &FS) {
+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);
@@ -1279,7 +1279,8 @@
   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;
 
@@ -1344,9 +1345,10 @@
   BumpPtrAllocator A;
   StringSaver Saver(A);
   ExpandResponseFiles(Saver,
-         Triple(sys::getProcessTriple()).isOSWindows() ?
-         cl::TokenizeWindowsCommandLine : cl::TokenizeGNUCommandLine,
-         newArgv);
+                      Triple(sys::getProcessTriple()).isOSWindows()
+                          ? cl::TokenizeWindowsCommandLine
+                          : cl::TokenizeGNUCommandLine,
+                      newArgv);
   argv = &newArgv[0];
   argc = static_cast<int>(newArgv.size());
 
@@ -1382,7 +1384,7 @@
   auto &SinkOpts = ChosenSubCommand->SinkOpts;
   auto &OptionsMap = ChosenSubCommand->OptionsMap;
 
-  for (auto O: DefaultOptions) {
+  for (auto O : DefaultOptions) {
     addOption(O, true);
   }
 
@@ -1546,22 +1548,22 @@
       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";
+    *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 &&
@@ -1724,9 +1726,7 @@
 //
 
 // 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) {
@@ -1938,8 +1938,7 @@
 // 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))
@@ -1977,8 +1976,7 @@
 
     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);
@@ -2466,23 +2464,23 @@
 #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 {
@@ -2564,7 +2562,9 @@
 /// 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)
@@ -2588,8 +2588,7 @@
 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);
     }
   }
diff --git a/llvm/unittests/Support/CommandLineTest.cpp b/llvm/unittests/Support/CommandLineTest.cpp
--- a/llvm/unittests/Support/CommandLineTest.cpp
+++ b/llvm/unittests/Support/CommandLineTest.cpp
@@ -38,15 +38,14 @@
 }
 
 class TempEnvVar {
- public:
-  TempEnvVar(const char *name, const char *value)
-      : name(name) {
+public:
+  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
   }
 
@@ -59,7 +58,7 @@
 #endif
   }
 
- private:
+private:
   const char *const name;
 };
 
@@ -79,8 +78,7 @@
 
 class StackSubCommand : public cl::SubCommand {
 public:
-  StackSubCommand(StringRef Name,
-                  StringRef Description = StringRef())
+  StackSubCommand(StringRef Name, StringRef Description = StringRef())
       : SubCommand(Name, Description) {}
 
   StackSubCommand() : SubCommand() {}
@@ -88,7 +86,6 @@
   ~StackSubCommand() { unregisterSubCommand(); }
 };
 
-
 cl::OptionCategory TestCategory("Test Options", "Description");
 TEST(CommandLineTest, ModifyExisitingOption) {
   StackOption<int> TestOption("test-option", cl::desc("old description"));
@@ -100,8 +97,7 @@
   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.";
@@ -134,8 +130,8 @@
       << "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
 
@@ -166,16 +162,16 @@
   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;
-                         }))
+                    [&](const llvm::cl::OptionCategory *Cat) {
+                      return Cat == &TestCategory;
+                    }))
       << "Failed to assign Option Category.";
 }
 
@@ -189,15 +185,15 @@
 
   ASSERT_NE(TestOption2.Categories.end(),
             find_if(TestOption2.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &TestCategory;
-                         }))
+                    [&](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;
-                         }))
+                    [&](const llvm::cl::OptionCategory *Cat) {
+                      return Cat == &cl::GeneralCategory;
+                    }))
       << "Failed to assign General Category.";
 
   cl::OptionCategory AnotherCategory("Additional test Options", "Description");
@@ -205,21 +201,21 @@
                               cl::cat(AnotherCategory));
   ASSERT_EQ(TestOption.Categories.end(),
             find_if(TestOption.Categories,
-                         [&](const llvm::cl::OptionCategory *Cat) {
-                           return Cat == &cl::GeneralCategory;
-                         }))
+                    [&](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;
-                         }))
+                    [&](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;
-                         }))
+                    [&](const llvm::cl::OptionCategory *Cat) {
+                      return Cat == &AnotherCategory;
+                    }))
       << "Failed to assign Another Category.";
 }
 
@@ -245,74 +241,85 @@
   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));
 }
@@ -335,26 +342,24 @@
 
 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");
@@ -383,8 +388,8 @@
 }
 
 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);
 }
@@ -733,8 +738,8 @@
 
   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");
@@ -765,8 +770,8 @@
   // 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());
@@ -921,8 +926,10 @@
 
   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()));
 
@@ -988,7 +995,7 @@
   const char *args[] = {"prog", "-opt1=false", "-opt2", "-opt3"};
 
   EXPECT_TRUE(
-    cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
+      cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 
   EXPECT_TRUE(Opt1 == "false");
   EXPECT_TRUE(Opt2);
@@ -1086,15 +1093,22 @@
 
   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());
@@ -1111,8 +1125,8 @@
   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]);
 }
@@ -1157,7 +1171,7 @@
   // 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));
@@ -1621,28 +1635,31 @@
   // 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();
 
   //
@@ -1652,25 +1669,30 @@
 
   // 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();
 }
 
@@ -1728,9 +1750,9 @@
   cl::ResetCommandLineParser();
 
   StackOption<bool> OptA("a", cl::desc("option a"));
-  StackOption<bool> OptB(
-      "b", cl::desc("option b -- This option turns on option a"),
-      cl::callback([&](const bool &) { OptA = true; }));
+  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; }));
@@ -1738,8 +1760,7 @@
       "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;
       }));
@@ -1787,11 +1808,10 @@
 }
 
 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"),
-      clEnumValN(Val1, "bits-val2", "The Val2 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();