Fix parsing flags and add test (#519)

Author: mamaria-k

source/citnames/source/semantic/Parsers.cc

@@ -200,19 +200,21 @@ namespace cs::semantic {
             if (auto result = check_equal(key, *candidate); result) {
                 return result;
             }
-            // check if the argument is allowed to stick to the flag
-            if (auto result = check_partial(key, *candidate); result) {
-                return result;
-            }
         }
-        // partial match is less likely to be a few steps away from the lower bound,
-        // therefore search the whole flag list again.
-        for (const auto &candidate : flags_) {
-            if (auto result = check_partial(key, candidate); result) {
-                return result;
+
+        std::optional<std::string> candidate_longest = std::nullopt;
+        for (const auto &[candidate, info] : flags_) {
+            if (const auto& extra = split_extra(candidate, key); extra) {
+                const size_t prefix_length = key.size() - extra.value().size();
+                if (!candidate_longest || (prefix_length > candidate_longest.value().size())) {
+                    candidate_longest = std::make_optional(std::string(candidate));
+                }
             }
         }
-        return std::nullopt;
+
+        return (candidate_longest.has_value())
+            ? check_partial(key, *(flags_.find(candidate_longest.value())))
+            : std::nullopt;
     }
 
     std::optional<FlagParser::Match>
@@ -228,26 +230,24 @@ namespace cs::semantic {
     std::optional<FlagParser::Match>
     FlagParser::check_partial(const std::string_view &key, const FlagsByName::value_type &candidate) {
         const auto &flag_definition = candidate.second;
-        if (const auto &extra = split_extra(candidate.first, key); extra) {
-            const auto flag_matching = classify_flag_matching(extra.value());
-            switch (flag_matching) {
-                case FlagMatch::GLUED:
-                    if (is_glue_allowed(flag_definition.match)) {
-                        const size_t decrease = is_prefix_match(flag_definition.match) ? 0 : 1;
-                        const size_t count = count_of_arguments(flag_definition.match) - decrease;
-                        return std::make_optional(std::make_tuple(count, flag_definition.type));
-                    }
-                    break;
-                case FlagMatch::GLUED_WITH_EQ:
-                    if (is_glue_with_equal_allowed(flag_definition.match)) {
-                        const size_t count = count_of_arguments(flag_definition.match) - 1;
-                        return std::make_optional(std::make_tuple(count, flag_definition.type));
-                    }
-                    break;
-                default:
-                    // This should not happen here. Exact match is already filtered out.
-                    return std::nullopt;
-            }
+        const auto flag_matching = classify_flag_matching(key.substr(candidate.first.size()));
+        switch (flag_matching) {
+            case FlagMatch::GLUED:
+                if (is_glue_allowed(flag_definition.match)) {
+                    const size_t decrease = is_prefix_match(flag_definition.match) ? 0 : 1;
+                    const size_t count = count_of_arguments(flag_definition.match) - decrease;
+                    return std::make_optional(std::make_tuple(count, flag_definition.type));
+                }
+                break;
+            case FlagMatch::GLUED_WITH_EQ:
+                if (is_glue_with_equal_allowed(flag_definition.match)) {
+                    const size_t count = count_of_arguments(flag_definition.match) - 1;
+                    return std::make_optional(std::make_tuple(count, flag_definition.type));
+                }
+                break;
+            default:
+                // This should not happen here. Exact match is already filtered out.
+                __builtin_unreachable();
         }
         return std::nullopt;
     }

source/citnames/test/ParserTest.cc

@@ -320,4 +320,25 @@ namespace {
             EXPECT_TRUE(flags.is_err());
         }
     }
+
+    TEST(Parser, parse_flags_with_several_suitable_prefixes) {
+        const FlagsByName flags_by_name = {
+                {"-l", {MatchInstruction::PREFIX, CompilerFlagType::LINKER}},
+                {"-language", {MatchInstruction::EXACTLY_WITH_1_OPT_SEP,  CompilerFlagType::OTHER}},
+                {"-linker", {MatchInstruction::PREFIX_WITH_2_OPTS, CompilerFlagType::OTHER}},
+        };
+        const auto sut = Repeat(FlagParser(flags_by_name));
+
+        {
+            const Arguments input = {"compiler", "-lin", "-language", "s", "-linkeriasds", "opt1", "opt2"};
+            const auto flags = parse(sut, input);
+            EXPECT_TRUE(flags.is_ok());
+            const CompilerFlags expected = {
+                    CompilerFlag{slice(input, 1), CompilerFlagType::LINKER},
+                    CompilerFlag{slice(input, 2, 4), CompilerFlagType::OTHER},
+                    CompilerFlag{slice(input, 4, 7), CompilerFlagType::OTHER},
+            };
+            EXPECT_EQ(expected, flags.unwrap());
+        }
+    }
 }