Move tests to the namespace of the code under test (#3244)

Rationale: this convention avoids forcing closely-related code to be far apart in the namespace hierarchy, and vice versa. By the same token, it makes the namespace hierarchy more consistent with the directory hierarchy.
2026-10-06 07:34:45 +01:00 · 2023-09-18 22:05:14 +00:00
parent d6f689ba07
commit e3d3122f1d
28 changed files with 155 additions and 162 deletions
@@ -10,16 +10,17 @@
 #include "llvm/Support/FormatVariadic.h"
 #include "testing/base/test_raw_ostream.h"

-namespace Carbon::Testing {
+namespace Carbon::CommandLine {
 namespace {

+using ::Carbon::Testing::TestRawOstream;
 using ::testing::ElementsAre;
 using ::testing::Eq;
 using ::testing::HasSubstr;
 using ::testing::Not;
 using ::testing::StrEq;

-constexpr CommandLine::CommandInfo TestCommandInfo = {
+constexpr CommandInfo TestCommandInfo = {
    .name = "test",
    .help = "A test command.",
    .help_epilogue = "TODO",
@@ -40,7 +41,7 @@ TEST(ArgParserTest, BasicCommand) {
  int integer_option = -1;
  llvm::StringRef string_option = "";
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args) {
-    return CommandLine::Parse(
+    return Parse(
        args, llvm::errs(), llvm::errs(), TestCommandInfo, [&](auto& b) {
          b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
          b.AddIntegerOption({.name = "option1"},
@@ -52,7 +53,7 @@ TEST(ArgParserTest, BasicCommand) {
  };

  EXPECT_THAT(parse({"--flag", "--option2=value", "--option1=42"}),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_THAT(integer_option, Eq(42));
  EXPECT_THAT(string_option, StrEq("value"));
@@ -61,46 +62,43 @@ TEST(ArgParserTest, BasicCommand) {
 TEST(ArgParserTest, BooleanFlags) {
  bool flag = false;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
      b.Do([] {});
    });
  };

-  EXPECT_THAT(parse({"--no-flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--no-flag"}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_FALSE(flag);

  EXPECT_THAT(parse({"--flag", "--no-flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_FALSE(flag);

  EXPECT_THAT(parse({"--no-flag", "--flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);

  EXPECT_THAT(parse({"--no-flag", "--flag", "--flag=false"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_FALSE(flag);

  EXPECT_THAT(parse({"--no-flag", "--flag=true"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);

  EXPECT_THAT(parse({"--no-flag", "--flag=true", "--no-flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_FALSE(flag);

  TestRawOstream os;
-  EXPECT_THAT(parse({"--no-flag=true"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--no-flag=true"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(
      os.TakeStr(),
      StrEq("ERROR: Cannot specify a value when using a flag name prefixed "
            "with 'no-' -- that prefix implies a value of 'false'.\n"));

-  EXPECT_THAT(parse({"--no-flag=false"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--no-flag=false"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(
      os.TakeStr(),
      StrEq("ERROR: Cannot specify a value when using a flag name prefixed "
@@ -112,7 +110,7 @@ TEST(ArgParserTest, ArgDefaults) {
  int integer_option = -1;
  llvm::StringRef string_option = "";
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddFlag({.name = "flag"}, [&](auto& arg_b) {
        arg_b.Default(true);
        arg_b.Set(&flag);
@@ -129,19 +127,19 @@ TEST(ArgParserTest, ArgDefaults) {
    });
  };

-  EXPECT_THAT(parse({}, llvm::errs()), Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_THAT(integer_option, Eq(7));
  EXPECT_THAT(string_option, StrEq("default"));

  EXPECT_THAT(parse({"--option1", "--option2"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_THAT(integer_option, Eq(7));
  EXPECT_THAT(string_option, StrEq("default"));

  EXPECT_THAT(parse({"--option1=42", "--option2=explicit"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_THAT(integer_option, Eq(42));
  EXPECT_THAT(string_option, StrEq("explicit"));
@@ -149,7 +147,7 @@ TEST(ArgParserTest, ArgDefaults) {
  EXPECT_THAT(
      parse({"--option1=42", "--option2=explicit", "--option1", "--option2"},
            llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_THAT(integer_option, Eq(7));
  EXPECT_THAT(string_option, StrEq("default"));
@@ -160,7 +158,7 @@ TEST(ArgParserTest, ShortArgs) {
  bool example = false;
  int integer_option = -1;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddFlag({.name = "flag", .short_name = "f"},
                [&](auto& arg_b) { arg_b.Set(&flag); });
      b.AddFlag({.name = "example", .short_name = "x"},
@@ -177,7 +175,7 @@ TEST(ArgParserTest, ShortArgs) {
  };

  EXPECT_THAT(parse({"-f", "-o=42", "-x"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_TRUE(example);
  EXPECT_THAT(integer_option, Eq(42));
@@ -185,18 +183,18 @@ TEST(ArgParserTest, ShortArgs) {
  flag = false;
  example = false;
  EXPECT_THAT(parse({"--option1=13", "-xfo"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_TRUE(example);
  EXPECT_THAT(integer_option, Eq(123));

  TestRawOstream os;
-  EXPECT_THAT(parse({"-xzf"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"-xzf"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(),
              StrEq("ERROR: Option '-z' (short for '--option2') requires a "
                    "value to be provided and none was.\n"));

-  EXPECT_THAT(parse({"-xz=123"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"-xz=123"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(
      os.TakeStr(),
      StrEq("ERROR: Cannot provide a value to the group of multiple short "
@@ -210,7 +208,7 @@ TEST(ArgParserTest, PositionalArgs) {
  llvm::StringRef source_string;
  llvm::StringRef dest_string;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
      b.AddStringOption({.name = "option"},
                        [&](auto& arg_b) { arg_b.Set(&string_option); });
@@ -227,27 +225,25 @@ TEST(ArgParserTest, PositionalArgs) {
  };

  TestRawOstream os;
-  EXPECT_THAT(parse({"--flag", "--option=x"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag", "--option=x"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(
      os.TakeStr(),
      StrEq("ERROR: Not all required positional arguments were provided. First "
            "missing and required positional argument: 'source'\n"));

  EXPECT_THAT(parse({"src", "--flag", "--option=value", "dst"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_THAT(string_option, StrEq("value"));
  EXPECT_THAT(source_string, StrEq("src"));
  EXPECT_THAT(dest_string, StrEq("dst"));

  EXPECT_THAT(parse({"src2", "--", "dst2"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(source_string, StrEq("src2"));
  EXPECT_THAT(dest_string, StrEq("dst2"));

-  EXPECT_THAT(parse({"-", "--", "-"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"-", "--", "-"}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_THAT(source_string, StrEq("-"));
  EXPECT_THAT(dest_string, StrEq("-"));
 }
@@ -258,7 +254,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
  llvm::SmallVector<llvm::StringRef> source_strings;
  llvm::SmallVector<llvm::StringRef> dest_strings;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
      b.AddStringOption({.name = "option"},
                        [&](auto& arg_b) { arg_b.Set(&string_option); });
@@ -275,8 +271,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
  };

  TestRawOstream os;
-  EXPECT_THAT(parse({"--flag", "--option=x"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag", "--option=x"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(
      os.TakeStr(),
      StrEq("ERROR: Not all required positional arguments were provided. First "
@@ -285,7 +280,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
  EXPECT_THAT(
      parse({"src1", "--flag", "src2", "--option=value", "--", "--dst--"},
            llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
  EXPECT_TRUE(flag);
  EXPECT_THAT(string_option, StrEq("value"));
  EXPECT_THAT(source_strings, ElementsAre(StrEq("src1"), StrEq("src2")));
@@ -295,7 +290,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
  dest_strings.clear();
  EXPECT_THAT(
      parse({"--", "--src1--", "--src2--", "--", "dst1", "dst2"}, llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
  EXPECT_THAT(source_strings,
              ElementsAre(StrEq("--src1--"), StrEq("--src2--")));
  EXPECT_THAT(dest_strings, ElementsAre(StrEq("dst1"), StrEq("dst2")));
@@ -303,7 +298,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
  source_strings.clear();
  dest_strings.clear();
  EXPECT_THAT(parse({"--", "--", "dst1", "dst2"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(source_strings, ElementsAre());
  EXPECT_THAT(dest_strings, ElementsAre(StrEq("dst1"), StrEq("dst2")));
 }
@@ -317,7 +312,7 @@ TEST(ArgParserTest, BasicSubcommands) {
  bool subsub_command = false;

  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddSubcommand({.name = "sub1"}, [&](auto& sub_b) {
        sub_b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
        sub_b.AddStringOption({.name = "option"},
@@ -339,40 +334,39 @@ TEST(ArgParserTest, BasicSubcommands) {
  };

  TestRawOstream os;
-  EXPECT_THAT(parse({}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq("ERROR: No subcommand specified. Available "
                                  "subcommands: 'sub1', 'sub2', or 'help'\n"));

-  EXPECT_THAT(parse({"--flag"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Unknown option '--flag'\n"));

-  EXPECT_THAT(parse({"sub3"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"sub3"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Invalid subcommand 'sub3'. Available "
                                  "subcommands: 'sub1', 'sub2', or 'help'\n"));

-  EXPECT_THAT(parse({"--flag", "sub1"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--flag", "sub1"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Unknown option '--flag'\n"));

  EXPECT_THAT(parse({"sub1", "--flag"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub1));
  EXPECT_TRUE(flag);

  EXPECT_THAT(parse({"sub2", "--option=value"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub2));
  EXPECT_THAT(option1, StrEq("value"));

  EXPECT_THAT(parse({"sub2", "--option=abc", "subsub42", "--option=xyz"}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(),
              StrEq("ERROR: Invalid subcommand 'subsub42'. Available "
                    "subcommands: 'subsub', or 'help'\n"));

  EXPECT_THAT(
      parse({"sub2", "--option=abc", "subsub", "--option=xyz"}, llvm::errs()),
-      Eq(CommandLine::ParseResult::Success));
+      Eq(ParseResult::Success));
  EXPECT_TRUE(subsub_command);
  EXPECT_THAT(option1, StrEq("abc"));
  EXPECT_THAT(option2, StrEq("xyz"));
@@ -382,7 +376,7 @@ TEST(ArgParserTest, Appending) {
  llvm::SmallVector<int> integers;
  llvm::SmallVector<llvm::StringRef> strings;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddIntegerOption({.name = "int"},
                         [&](auto& arg_b) { arg_b.Append(&integers); });
      b.AddStringOption({.name = "str"},
@@ -391,22 +385,22 @@ TEST(ArgParserTest, Appending) {
    });
  };

-  EXPECT_THAT(parse({}, llvm::errs()), Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_THAT(integers, ElementsAre());
  EXPECT_THAT(strings, ElementsAre());

  EXPECT_THAT(parse({"--int=1", "--int=2", "--int=3"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3)));
  EXPECT_THAT(strings, ElementsAre());

  EXPECT_THAT(parse({"--str=a", "--str=b", "--str=c"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3)));
  EXPECT_THAT(strings, ElementsAre(StrEq("a"), StrEq("b"), StrEq("c")));

  EXPECT_THAT(parse({"--str=d", "--int=4", "--str=e"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3), Eq(4)));
  EXPECT_THAT(strings, ElementsAre(StrEq("a"), StrEq("b"), StrEq("c"),
                                   StrEq("d"), StrEq("e")));
@@ -418,7 +412,7 @@ TEST(ArgParserTest, PositionalAppending) {
  llvm::SmallVector<llvm::StringRef> strings2;
  llvm::SmallVector<llvm::StringRef> strings3;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddStringOption({.name = "opt"},
                        [&](auto& arg_b) { arg_b.Append(&option_strings); });
      b.AddStringPositionalArg({.name = "s1"},
@@ -434,7 +428,7 @@ TEST(ArgParserTest, PositionalAppending) {
  EXPECT_THAT(parse({"a", "--opt=x", "b", "--opt=y", "--", "c", "--opt=z", "d",
                     "--", "e", "f"},
                    llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(option_strings, ElementsAre(StrEq("x"), StrEq("y")));
  EXPECT_THAT(strings1, ElementsAre(StrEq("a"), StrEq("b")));
  EXPECT_THAT(strings2, ElementsAre(StrEq("c"), StrEq("--opt=z"), StrEq("d")));
@@ -444,7 +438,7 @@ TEST(ArgParserTest, PositionalAppending) {
 TEST(ArgParserTest, OneOfOption) {
  int value = 0;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddOneOfOption({.name = "option"}, [&](auto& arg_b) {
        arg_b.SetOneOf(
            {
@@ -458,44 +452,40 @@ TEST(ArgParserTest, OneOfOption) {
    });
  };

-  EXPECT_THAT(parse({"--option=x"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--option=x"}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_THAT(value, Eq(1));

-  EXPECT_THAT(parse({"--option=y"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--option=y"}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_THAT(value, Eq(2));

-  EXPECT_THAT(parse({"--option=z"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({"--option=z"}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_THAT(value, Eq(3));

  constexpr const char* ErrorStr =
      "ERROR: Option '--option={0}' has an invalid value '{0}'; valid values "
      "are: 'x', 'y', or 'z'\n";
  TestRawOstream os;
-  EXPECT_THAT(parse({"--option=a"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option=a"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "a")));

-  EXPECT_THAT(parse({"--option="}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option="}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "")));

-  EXPECT_THAT(parse({"--option=xx"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option=xx"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "xx")));

-  EXPECT_THAT(parse({"--option=\xFF"}, os),
-              Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--option=\xFF"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "\\FF")));

  EXPECT_THAT(parse({llvm::StringRef("--option=\0", 10)}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "\\00")));
 }

 TEST(ArgParserTest, OneOfOptionAppending) {
  llvm::SmallVector<int> values;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddOneOfOption({.name = "option"}, [&](auto& arg_b) {
        arg_b.AppendOneOf(
            {
@@ -509,15 +499,15 @@ TEST(ArgParserTest, OneOfOptionAppending) {
    });
  };

-  EXPECT_THAT(parse({}, llvm::errs()), Eq(CommandLine::ParseResult::Success));
+  EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
  EXPECT_THAT(values, ElementsAre());

  EXPECT_THAT(parse({"--option=x", "--option=y", "--option=z"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(values, ElementsAre(Eq(1), Eq(2), Eq(3)));

  EXPECT_THAT(parse({"--option=y", "--option=y", "--option=x"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(values, ElementsAre(Eq(1), Eq(2), Eq(3), Eq(2), Eq(2), Eq(1)));
 }

@@ -531,7 +521,7 @@ TEST(ArgParserTest, RequiredArgs) {
  TestEnum enum_sub_option;

  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(args, s, s, TestCommandInfo, [&](auto& b) {
+    return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
      b.AddIntegerOption({.name = "opt1"}, [&](auto& arg_b) {
        arg_b.Required(true);
        arg_b.Set(&integer_option);
@@ -578,28 +568,28 @@ TEST(ArgParserTest, RequiredArgs) {
  constexpr const char* ErrorStr =
      "ERROR: Required option '{0}' not provided.\n";
  TestRawOstream os;
-  EXPECT_THAT(parse({}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({}, os), Eq(ParseResult::Error));
  auto errors = os.TakeStr();
  EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--opt1")));
  EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--opt2")));

-  EXPECT_THAT(parse({"--opt2=xyz"}, os), Eq(CommandLine::ParseResult::Error));
+  EXPECT_THAT(parse({"--opt2=xyz"}, os), Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "--opt1")));

  EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42"}, llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(integer_option, Eq(42));
  EXPECT_THAT(string_option, StrEq("xyz"));

  EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2"}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
  errors = os.TakeStr();
  EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt1")));
  EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt2")));
  EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt3")));

  EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b"}, os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
  errors = os.TakeStr();
  EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt1")));
  EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt2")));
@@ -608,13 +598,13 @@ TEST(ArgParserTest, RequiredArgs) {
  EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b",
                     "--sub-opt1=13"},
                    os),
-              Eq(CommandLine::ParseResult::Error));
+              Eq(ParseResult::Error));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "--sub-opt2")));

  EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b",
                     "--sub-opt1=13", "--sub-opt2=abc"},
                    llvm::errs()),
-              Eq(CommandLine::ParseResult::Success));
+              Eq(ParseResult::Success));
  EXPECT_THAT(integer_option, Eq(42));
  EXPECT_THAT(string_option, StrEq("xyz"));
  EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub2));
@@ -628,7 +618,7 @@ TEST(ArgParserTest, HelpAndVersion) {
  int storage = -1;
  llvm::StringRef string = "";
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(  // Force line break.
+    return Parse(  // Force line break.
        args, s, s,
        {
            .name = "test",
@@ -747,8 +737,7 @@ A hidden subcommand.
  };

  TestRawOstream os;
-  EXPECT_THAT(parse({"--flag", "--help"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"--flag", "--help"}, os), Eq(ParseResult::MetaSuccess));
  std::string help_flag_output = os.TakeStr();
  EXPECT_THAT(help_flag_output, StrEq(llvm::StringRef(R"""(
 Test Command -- version 1.2.3
@@ -790,11 +779,10 @@ Closing remarks.

 )""")
                                          .ltrim('\n')));
-  EXPECT_THAT(parse({"help"}, os), Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"help"}, os), Eq(ParseResult::MetaSuccess));
  EXPECT_THAT(os.TakeStr(), StrEq(help_flag_output));

-  EXPECT_THAT(parse({"--version"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"--version"}, os), Eq(ParseResult::MetaSuccess));
  std::string version_flag_output = os.TakeStr();
  EXPECT_THAT(version_flag_output, StrEq(llvm::StringRef(R"""(
 Test Command -- version 1.2.3
@@ -803,12 +791,11 @@ Build timestamp: )""" __TIMESTAMP__ R"""(
 Build config: test-config-info
 )""")
                                             .ltrim('\n')));
-  EXPECT_THAT(parse({"version"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"version"}, os), Eq(ParseResult::MetaSuccess));
  EXPECT_THAT(os.TakeStr(), StrEq(version_flag_output));

  EXPECT_THAT(parse({"--flag", "edit", "--option=42", "--help"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+              Eq(ParseResult::MetaSuccess));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::StringRef(R"""(
 Edit the widget.

@@ -834,7 +821,7 @@ That's all.
                                      .ltrim('\n')));

  EXPECT_THAT(parse({"--flag", "run", "--option=abc", "--help"}, os),
-              Eq(CommandLine::ParseResult::MetaSuccess));
+              Eq(ParseResult::MetaSuccess));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::StringRef(R"""(
 Run wombats across the screen.

@@ -871,7 +858,7 @@ Or it won't, who knows.
 TEST(ArgParserTest, HelpMarkdownLike) {
  bool flag = false;
  auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
-    return CommandLine::Parse(  // Force line break.
+    return Parse(  // Force line break.
        args, s, s, {.name = "test"}, [&](auto& b) {
          b.AddFlag(
              {
@@ -902,7 +889,7 @@ x
  };

  TestRawOstream os;
-  EXPECT_THAT(parse({"--help"}, os), Eq(CommandLine::ParseResult::MetaSuccess));
+  EXPECT_THAT(parse({"--help"}, os), Eq(ParseResult::MetaSuccess));
  EXPECT_THAT(os.TakeStr(), StrEq(llvm::StringRef(R"""(
 Usage:
  test [--flag]
@@ -935,4 +922,4 @@ Options:
 }

 }  // namespace
-}  // namespace Carbon::Testing
+}  // namespace Carbon::CommandLine