Delete unused FlagAliasMode::kFlagConsumesArbitrary

Author: jemoreira

base/cvd/cuttlefish/common/libs/utils/flag_parser.cpp

@@ -27,7 +27,6 @@
 #include <iterator>
 #include <string>
 #include <string_view>
-#include <type_traits>
 #include <unordered_set>
 #include <utility>
 #include <vector>
@@ -98,18 +97,9 @@ void Flag::ValidateAlias(const FlagAlias& alias) {
   if (alias.mode == FlagAliasMode::kFlagConsumesFollowing) {
     CHECK(!HasAlias({FlagAliasMode::kFlagExact, alias.name}))
         << "Overlapping flag aliases for " << alias.name;
-    CHECK(!HasAlias({FlagAliasMode::kFlagConsumesArbitrary, alias.name}))
-        << "Overlapping flag aliases for " << alias.name;
   } else if (alias.mode == FlagAliasMode::kFlagExact) {
     CHECK(!HasAlias({FlagAliasMode::kFlagConsumesFollowing, alias.name}))
         << "Overlapping flag aliases for " << alias.name;
-    CHECK(!HasAlias({FlagAliasMode::kFlagConsumesArbitrary, alias.name}))
-        << "Overlapping flag aliases for " << alias.name;
-  } else if (alias.mode == FlagAliasMode::kFlagConsumesArbitrary) {
-    CHECK(!HasAlias({FlagAliasMode::kFlagExact, alias.name}))
-        << "Overlapping flag aliases for " << alias.name;
-    CHECK(!HasAlias({FlagAliasMode::kFlagConsumesFollowing, alias.name}))
-        << "Overlapping flag aliases for " << alias.name;
   }
 }
 
@@ -151,10 +141,6 @@ Flag Flag::Setter(std::function<Result<void>(const FlagMatch&)> setter) && {
   return *this;
 }
 
-static bool LikelyFlag(const std::string& next_arg) {
-  return absl::StartsWith(next_arg, "-");
-}
-
 Result<bool> ParseBool(std::string_view value, std::string_view name) {
   bool result;
   CF_EXPECTF(absl::SimpleAtob(value, &result),
@@ -178,17 +164,6 @@ Result<Flag::FlagProcessResult> Flag::Process(
   for (auto& alias : aliases_) {
     auto normalized_alias = absl::StrReplaceAll(alias.name, {{"-", "_"}});
     switch (alias.mode) {
-      case FlagAliasMode::kFlagConsumesArbitrary:
-        if (normalized_arg != normalized_alias) {
-          continue;
-        }
-        if (!next_arg || LikelyFlag(*next_arg)) {
-          CF_EXPECTF((*setter_)({arg, ""}), "Processing \"{}\" failed", arg);
-          return FlagProcessResult::kFlagConsumed;
-        }
-        CF_EXPECTF((*setter_)({arg, *next_arg}),
-                   "Processing \"{}\" \"{}\" failed", arg, *next_arg);
-        return FlagProcessResult::kFlagConsumedOnlyFollowing;
       case FlagAliasMode::kFlagConsumesFollowing:
         if (normalized_arg != normalized_alias) {
           continue;
@@ -232,9 +207,6 @@ Result<void> Flag::Parse(std::vector<std::string>& arguments) const {
       case FlagProcessResult::kFlagConsumedWithFollowing:
         arguments.erase(arguments.begin() + i, arguments.begin() + i + 2);
         break;
-      case FlagProcessResult::kFlagConsumedOnlyFollowing:
-        arguments.erase(arguments.begin() + i + 1, arguments.begin() + i + 2);
-        break;
       case FlagProcessResult::kFlagSkip:
         i++;
         break;
@@ -451,9 +423,6 @@ Result<void> ConsumeFlagsConstrained(const std::vector<Flag>& flags,
       case Flag::FlagProcessResult::kFlagConsumedWithFollowing:
         args.erase(args.begin(), args.begin() + 2);
         break;
-      case Flag::FlagProcessResult::kFlagConsumedOnlyFollowing:
-        args.erase(args.begin() + 1, args.begin() + 2);
-        break;
     }
   }
   return {};

base/cvd/cuttlefish/common/libs/utils/flag_parser.h

@@ -51,10 +51,6 @@ enum class FlagAliasMode {
   /* Match a pair of arguments of the form `<name>` `<value>`. In practice,
    * <name> will look like "-flag" or "--flag". */
   kFlagConsumesFollowing,
-  /* Match a sequence of arguments of the form `<name>` `<value>` `<value>`.
-   * This uses heuristics to try to determine when `<value>` is actually another
-   * flag. */
-  kFlagConsumesArbitrary,
 };
 
 /* A single matching rule for a `Flag`. One `Flag` can have multiple rules. */
@@ -105,7 +101,6 @@ class Flag {
     kFlagSkip,                  /* Flag skipped; consume no arguments. */
     kFlagConsumed,              /* Flag processed; consume one argument. */
     kFlagConsumedWithFollowing, /* Flag processed; consume 2 arguments. */
-    kFlagConsumedOnlyFollowing, /* Flag processed; consume next argument. */
   };
 
   void ValidateAlias(const FlagAlias& alias);

base/cvd/cuttlefish/common/libs/utils/flag_parser_test.cpp

@@ -424,61 +424,4 @@ TEST(FlagParser, ConsumesConstrainedSeparated) {
   EXPECT_EQ(name, "abc");
 }
 
-class FlagConsumesArbitraryTest : public ::testing::Test {
- protected:
-  void SetUp() override {
-    elems_.clear();
-    flag_ = Flag()
-                .Alias({FlagAliasMode::kFlagConsumesArbitrary, "--flag"})
-                .Setter([this](const FlagMatch& match) -> Result<void> {
-                  elems_.push_back(match.value);
-                  return {};
-                });
-  }
-  Flag flag_;
-  std::vector<std::string> elems_;
-};
-
-TEST_F(FlagConsumesArbitraryTest, NoValues) {
-  std::vector<std::string> inputs = {"--flag"};
-  ASSERT_THAT(flag_.Parse(inputs), IsOk());
-  ASSERT_EQ(inputs, (std::vector<std::string>{}));
-  ASSERT_EQ(elems_, (std::vector<std::string>{""}));
-}
-
-TEST_F(FlagConsumesArbitraryTest, OneValue) {
-  std::vector<std::string> inputs = {"--flag", "value"};
-  ASSERT_THAT(flag_.Parse(inputs), IsOk());
-  ASSERT_EQ(inputs, (std::vector<std::string>{}));
-  ASSERT_EQ(elems_, (std::vector<std::string>{"value", ""}));
-}
-
-TEST_F(FlagConsumesArbitraryTest, TwoValues) {
-  std::vector<std::string> inputs = {"--flag", "value1", "value2"};
-  ASSERT_THAT(flag_.Parse(inputs), IsOk());
-  ASSERT_EQ(inputs, (std::vector<std::string>{}));
-  ASSERT_EQ(elems_, (std::vector<std::string>{"value1", "value2", ""}));
-}
-
-TEST_F(FlagConsumesArbitraryTest, NoValuesOtherFlag) {
-  std::vector<std::string> inputs = {"--flag", "--otherflag"};
-  ASSERT_THAT(flag_.Parse(inputs), IsOk());
-  ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
-  ASSERT_EQ(elems_, (std::vector<std::string>{""}));
-}
-
-TEST_F(FlagConsumesArbitraryTest, OneValueOtherFlag) {
-  std::vector<std::string> inputs = {"--flag", "value", "--otherflag"};
-  ASSERT_THAT(flag_.Parse(inputs), IsOk());
-  ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
-  ASSERT_EQ(elems_, (std::vector<std::string>{"value", ""}));
-}
-
-TEST_F(FlagConsumesArbitraryTest, TwoValuesOtherFlag) {
-  std::vector<std::string> inputs = {"--flag", "v1", "v2", "--otherflag"};
-  ASSERT_THAT(flag_.Parse(inputs), IsOk());
-  ASSERT_EQ(inputs, (std::vector<std::string>{"--otherflag"}));
-  ASSERT_EQ(elems_, (std::vector<std::string>{"v1", "v2", ""}));
-}
-
 }  // namespace cuttlefish