more cleaning

include/ada/url_pattern.h

@@ -94,8 +94,8 @@ struct url_pattern_compile_component_options {
       std::optional<char> new_prefix = std::nullopt)
       : delimiter(new_delimiter), prefix(new_prefix) {}
 
-  std::string_view get_delimiter() const ada_warn_unused;
-  std::string_view get_prefix() const ada_warn_unused;
+  inline std::string_view get_delimiter() const ada_warn_unused;
+  inline std::string_view get_prefix() const ada_warn_unused;
 
   // @see https://urlpattern.spec.whatwg.org/#options-ignore-case
   bool ignore_case = false;

include/ada/url_pattern_helpers-inl.h

@@ -112,7 +112,7 @@ bool constructor_string_parser<regex_provider>::is_non_special_pattern_char(
 }
 
 template <url_pattern_regex::regex_concept regex_provider>
-const Token* constructor_string_parser<regex_provider>::get_safe_token(
+const token* constructor_string_parser<regex_provider>::get_safe_token(
     size_t index) {
   // If index is less than parser’s token list's size, then return parser’s
   // token list[index].
@@ -440,7 +440,7 @@ Tokenizer::process_tokenizing_error(size_t next_position,
 }
 
 template <url_pattern_encoding_callback F>
-Token* url_pattern_parser<F>::try_consume_modifier_token() {
+token* url_pattern_parser<F>::try_consume_modifier_token() {
   // Let token be the result of running try to consume a token given parser and
   // "other-modifier".
   auto token = try_consume_token(token_type::OTHER_MODIFIER);
@@ -453,8 +453,8 @@ Token* url_pattern_parser<F>::try_consume_modifier_token() {
 }
 
 template <url_pattern_encoding_callback F>
-Token* url_pattern_parser<F>::try_consume_regexp_or_wildcard_token(
-    Token* name_token) {
+token* url_pattern_parser<F>::try_consume_regexp_or_wildcard_token(
+    const token* name_token) {
   // Let token be the result of running try to consume a token given parser and
   // "regexp".
   auto token = try_consume_token(token_type::REGEXP);
@@ -468,7 +468,7 @@ Token* url_pattern_parser<F>::try_consume_regexp_or_wildcard_token(
 }
 
 template <url_pattern_encoding_callback F>
-Token* url_pattern_parser<F>::try_consume_token(token_type type) {
+token* url_pattern_parser<F>::try_consume_token(token_type type) {
   ada_log("url_pattern_parser::try_consume_token called with type=",
           to_string(type));
   // Assert: parser’s index is less than parser’s token list size.
@@ -541,8 +541,8 @@ url_pattern_parser<F>::maybe_add_part_from_the_pending_fixed_value() {
 
 template <url_pattern_encoding_callback F>
 std::optional<errors> url_pattern_parser<F>::add_part(
-    std::string_view prefix, Token* name_token, Token* regexp_or_wildcard_token,
-    std::string_view suffix, Token* modifier_token) {
+    std::string_view prefix, token* name_token, token* regexp_or_wildcard_token,
+    std::string_view suffix, token* modifier_token) {
   // Let modifier be "none".
   auto modifier = url_pattern_part_modifier::NONE;
   // If modifier token is not null:

include/ada/url_pattern_helpers.h

@@ -42,9 +42,9 @@ enum class token_policy {
 };
 
 // @see https://urlpattern.spec.whatwg.org/#tokens
-class Token {
+class token {
  public:
-  Token(token_type _type, size_t _index, std::string&& _value)
+  token(token_type _type, size_t _index, std::string&& _value)
       : type(_type), index(_index), value(std::move(_value)) {}
 
   // A token has an associated type, a string, initially "invalid-char".
@@ -71,12 +71,12 @@ class url_pattern_parser {
   bool can_continue() const { return index < tokens.size(); }
 
   // @see https://urlpattern.spec.whatwg.org/#try-to-consume-a-token
-  Token* try_consume_token(token_type type);
+  token* try_consume_token(token_type type);
   // @see https://urlpattern.spec.whatwg.org/#try-to-consume-a-modifier-token
-  Token* try_consume_modifier_token();
+  token* try_consume_modifier_token();
   // @see
   // https://urlpattern.spec.whatwg.org/#try-to-consume-a-regexp-or-wildcard-token
-  Token* try_consume_regexp_or_wildcard_token(Token* name_token);
+  token* try_consume_regexp_or_wildcard_token(const token* name_token);
   // @see https://urlpattern.spec.whatwg.org/#consume-text
   std::string consume_text();
   // @see https://urlpattern.spec.whatwg.org/#consume-a-required-token
@@ -86,12 +86,12 @@ class url_pattern_parser {
   std::optional<errors> maybe_add_part_from_the_pending_fixed_value()
       ada_warn_unused;
   // @see https://urlpattern.spec.whatwg.org/#add-a-part
-  std::optional<errors> add_part(std::string_view prefix, Token* name_token,
-                                 Token* regexp_or_wildcard_token,
+  std::optional<errors> add_part(std::string_view prefix, token* name_token,
+                                 token* regexp_or_wildcard_token,
                                  std::string_view suyffix,
-                                 Token* modifier_token) ada_warn_unused;
+                                 token* modifier_token) ada_warn_unused;
 
-  std::vector<Token> tokens{};
+  std::vector<token> tokens{};
   F& encoding_callback;
   std::string segment_wildcard_regexp;
   std::vector<url_pattern_part> parts{};
@@ -134,7 +134,7 @@ class Tokenizer {
   // has an associated policy, a tokenize policy, initially "strict".
   token_policy policy;
   // has an associated token list, a token list, initially an empty list.
-  std::vector<Token> token_list{};
+  std::vector<token> token_list{};
   // has an associated index, a number, initially 0.
   size_t index = 0;
   // has an associated next index, a number, initially 0.
@@ -147,7 +147,7 @@ class Tokenizer {
 template <url_pattern_regex::regex_concept regex_provider>
 struct constructor_string_parser {
   explicit constructor_string_parser(std::string_view new_input,
-                                     std::vector<Token>&& new_token_list)
+                                     std::vector<token>&& new_token_list)
       : input(new_input), token_list(std::move(new_token_list)) {}
 
   // @see https://urlpattern.spec.whatwg.org/#rewind
@@ -218,7 +218,7 @@ struct constructor_string_parser {
   std::string input;
   // has an associated token list, a token list, which must be set upon
   // creation.
-  std::vector<Token> token_list;
+  std::vector<token> token_list;
   // has an associated result, a URLPatternInit, initially set to a new
   // URLPatternInit.
   url_pattern_init result{};
@@ -244,7 +244,7 @@ struct constructor_string_parser {
   bool is_non_special_pattern_char(size_t index, std::string_view value);
 
   // @see https://urlpattern.spec.whatwg.org/#get-a-safe-token
-  const Token* get_safe_token(size_t index);
+  const token* get_safe_token(size_t index);
 
   // @see https://urlpattern.spec.whatwg.org/#make-a-component-string
   std::string make_component_string();
@@ -287,7 +287,7 @@ tl::expected<std::string, errors> canonicalize_search(std::string_view input);
 tl::expected<std::string, errors> canonicalize_hash(std::string_view input);
 
 // @see https://urlpattern.spec.whatwg.org/#tokenize
-tl::expected<std::vector<Token>, errors> tokenize(std::string_view input,
+tl::expected<std::vector<token>, errors> tokenize(std::string_view input,
                                                   token_policy policy);
 
 // @see https://urlpattern.spec.whatwg.org/#process-a-base-url-string
@@ -319,7 +319,7 @@ std::string generate_pattern_string(
 // https://urlpattern.spec.whatwg.org/#generate-a-regular-expression-and-name-list
 std::tuple<std::string, std::vector<std::string>>
 generate_regular_expression_and_name_list(
-    std::vector<url_pattern_part>& part_list,
+    const std::vector<url_pattern_part>& part_list,
     url_pattern_compile_component_options options);
 
 // @see https://urlpattern.spec.whatwg.org/#hostname-pattern-is-an-ipv6-address

include/ada/url_search_params-inl.h

@@ -77,7 +77,7 @@ inline size_t url_search_params::size() const noexcept { return params.size(); }
 inline std::optional<std::string_view> url_search_params::get(
     const std::string_view key) {
   auto entry = std::ranges::find_if(
-      params, [&key](auto &param) { return param.first == key; });
+      params, [&key](const auto &param) { return param.first == key; });
 
   if (entry == params.end()) {
     return std::nullopt;
@@ -101,13 +101,13 @@ inline std::vector<std::string> url_search_params::get_all(
 
 inline bool url_search_params::has(const std::string_view key) noexcept {
   auto entry = std::ranges::find_if(
-      params, [&key](auto &param) { return param.first == key; });
+      params, [&key](const auto &param) { return param.first == key; });
   return entry != params.end();
 }
 
 inline bool url_search_params::has(std::string_view key,
                                    std::string_view value) noexcept {
-  auto entry = std::ranges::find_if(params, [&key, &value](auto &param) {
+  auto entry = std::ranges::find_if(params, [&key, &value](const auto &param) {
     return param.first == key && param.second == value;
   });
   return entry != params.end();
@@ -136,7 +136,7 @@ inline std::string url_search_params::to_string() const {
 
 inline void url_search_params::set(const std::string_view key,
                                    const std::string_view value) {
-  const auto find = [&key](auto &param) { return param.first == key; };
+  const auto find = [&key](const auto &param) { return param.first == key; };
 
   auto it = std::ranges::find_if(params, find);
 
@@ -150,12 +150,12 @@ inline void url_search_params::set(const std::string_view key,
 }
 
 inline void url_search_params::remove(const std::string_view key) {
-  std::erase_if(params, [&key](auto &param) { return param.first == key; });
+  std::erase_if(params, [&key](const auto &param) { return param.first == key; });
 }
 
 inline void url_search_params::remove(const std::string_view key,
                                       const std::string_view value) {
-  std::erase_if(params, [&key, &value](auto &param) {
+  std::erase_if(params, [&key, &value](const auto &param) {
     return param.first == key && param.second == value;
   });
 }

src/url_pattern_helpers.cpp

@@ -8,7 +8,7 @@ namespace ada::url_pattern_helpers {
 
 std::tuple<std::string, std::vector<std::string>>
 generate_regular_expression_and_name_list(
-    std::vector<url_pattern_part>& part_list,
+    const std::vector<url_pattern_part>& part_list,
     url_pattern_compile_component_options options) {
   // Let result be "^"
   std::string result = "^";
@@ -435,7 +435,7 @@ tl::expected<std::string, errors> canonicalize_hash(std::string_view input) {
   return tl::unexpected(errors::type_error);
 }
 
-tl::expected<std::vector<Token>, errors> tokenize(std::string_view input,
+tl::expected<std::vector<token>, errors> tokenize(std::string_view input,
                                                   token_policy policy) {
   ada_log("tokenize input: ", input);
   // Let tokenizer be a new tokenizer.