Function attr_search_impl

include/boost/parser/transform_replace.hpp:216–278

            typename ErrorHandler,
            typename SkipParser>
        auto attr_search_impl(
            R && r,
            parser_interface<Parser, GlobalState, ErrorHandler> const & parser,
            parser_interface<SkipParser> const & skip,
            trace trace_mode)
        {
            auto first = text::detail::begin(r);
            auto const last = text::detail::end(r);

            auto match_first = first;
            auto match_last = first;
            auto before = [&match_first](auto & ctx) {
                match_first = _where(ctx).begin();
            };
            auto after = [&match_last](auto & ctx) {
                match_last = _where(ctx).begin();
            };

            auto const search_parser =
                omit[*(char_ - parser)] >>
                -lexeme[eps[before] >> parser::skip[parser] >> eps[after]];

            using parse_result_outer = decltype(parser::prefix_parse(
                first, last, search_parser, trace_mode));

            static_assert(
                !std::is_same_v<parse_result_outer, bool>,
                "If you're seeing this error, you passed a parser to "
                "transform_replace() that has no attribute.  Please fix.");

            using parse_result =
                remove_cv_ref_t<decltype(**std::declval<parse_result_outer>())>;

            using return_tuple = tuple<
                decltype(BOOST_PARSER_SUBRANGE(first, first)),
                parse_result>;

            if (first == last) {
                return return_tuple(
                    BOOST_PARSER_SUBRANGE(first, first), parse_result{});
            }

            if constexpr (std::is_same_v<SkipParser, eps_parser<phony>>) {
                auto result = parser::prefix_parse(
                    first, last, search_parser, trace_mode);
                if (*result) {
                    return return_tuple(
                        BOOST_PARSER_SUBRANGE(match_first, match_last),
                        std::move(**result));
                }
            } else {
                auto result = parser::prefix_parse(
                    first, last, search_parser, skip, trace_mode);
                if (*result) {
                    return return_tuple(
                        BOOST_PARSER_SUBRANGE(match_first, match_last),
                        std::move(**result));
                }