optimize urlpattern::test

Author: anonrig

include/ada/url_pattern-inl.h

@@ -46,10 +46,11 @@ url_pattern_component<regex_provider>::create_component_match_result(
   // says we should start from 1. This case is handled by the
   // std_regex_provider.
   for (size_t index = 0; index < exec_result.size(); index++) {
-    result.groups.insert({
+    // Optimized: Use emplace instead of insert for better performance
+    result.groups.emplace(
         group_name_list[index],
-        std::move(exec_result[index]),
-    });
+        std::move(exec_result[index])
+    );
   }
   return result;
 }
@@ -204,16 +205,100 @@ result<std::optional<url_pattern_result>> url_pattern<regex_provider>::exec(
 
 template <url_pattern_regex::regex_concept regex_provider>
 result<bool> url_pattern<regex_provider>::test(
-    const url_pattern_input& input, const std::string_view* base_url) {
-  // TODO: Optimization opportunity. Rather than returning `url_pattern_result`
-  // Implement a fast path just like `can_parse()` in ada_url.
-  // Let result be the result of match given this's associated URL pattern,
-  // input, and baseURL if given.
-  // If result is null, return false.
-  if (auto result = match(input, base_url); result.has_value()) {
-    return result->has_value();
+    const url_pattern_input& input, const std::string_view* base_url_string) {
+  // Fast path: Use regex_match instead of full match() to avoid building result objects
+  std::string protocol{};
+  std::string username{};
+  std::string password{};
+  std::string hostname{};
+  std::string port{};
+  std::string pathname{};
+  std::string search{};
+  std::string hash{};
+
+  // If input is a URLPatternInit then:
+  if (std::holds_alternative<url_pattern_init>(input)) {
+    // If baseURLString was given, throw a TypeError.
+    if (base_url_string) {
+      return tl::unexpected(errors::type_error);
+    }
+
+    auto apply_result = url_pattern_init::process(
+        std::get<url_pattern_init>(input), url_pattern_init::process_type::url,
+        protocol, username, password, hostname, port, pathname, search, hash);
+
+    if (!apply_result.has_value()) {
+      return false;
+    }
+
+    ADA_ASSERT_TRUE(apply_result->protocol.has_value());
+    protocol = std::move(apply_result->protocol.value());
+    ADA_ASSERT_TRUE(apply_result->username.has_value());
+    username = std::move(apply_result->username.value());
+    ADA_ASSERT_TRUE(apply_result->password.has_value());
+    password = std::move(apply_result->password.value());
+    ADA_ASSERT_TRUE(apply_result->hostname.has_value());
+    hostname = std::move(apply_result->hostname.value());
+    ADA_ASSERT_TRUE(apply_result->port.has_value());
+    port = std::move(apply_result->port.value());
+    ADA_ASSERT_TRUE(apply_result->pathname.has_value());
+    pathname = std::move(apply_result->pathname.value());
+    ADA_ASSERT_TRUE(apply_result->search.has_value());
+    if (apply_result->search->starts_with("?")) {
+      search = apply_result->search->substr(1);
+    } else {
+      search = std::move(apply_result->search.value());
+    }
+    ADA_ASSERT_TRUE(apply_result->hash.has_value());
+    ADA_ASSERT_TRUE(!apply_result->hash->starts_with("#"));
+    hash = std::move(apply_result->hash.value());
+  } else {
+    ADA_ASSERT_TRUE(std::holds_alternative<std::string_view>(input));
+
+    result<url_aggregator> base_url;
+
+    if (base_url_string) {
+      base_url = ada::parse<url_aggregator>(*base_url_string, nullptr);
+      if (!base_url) {
+        return false;
+      }
+    }
+
+    url_aggregator* base_url_value =
+        base_url.has_value() ? &*base_url : nullptr;
+
+    auto url = ada::parse<url_aggregator>(std::get<std::string_view>(input),
+                                          base_url_value);
+
+    if (!url) {
+      return false;
+    }
+
+    protocol = url->get_protocol().substr(0, url->get_protocol().size() - 1);
+    username = url->get_username();
+    password = url->get_password();
+    hostname = url->get_hostname();
+    port = url->get_port();
+    pathname = url->get_pathname();
+    if (url->has_search()) {
+      auto view = url->get_search();
+      search = view.starts_with("?") ? url->get_search().substr(1) : view;
+    }
+    if (url->has_hash()) {
+      auto view = url->get_hash();
+      hash = view.starts_with("#") ? url->get_hash().substr(1) : view;
+    }
   }
-  return tl::unexpected(errors::type_error);
+
+  // Fast path: Just use regex_match for boolean testing, no need to extract groups
+  return regex_provider::regex_match(protocol, protocol_component.regexp) &&
+         regex_provider::regex_match(username, username_component.regexp) &&
+         regex_provider::regex_match(password, password_component.regexp) &&
+         regex_provider::regex_match(hostname, hostname_component.regexp) &&
+         regex_provider::regex_match(port, port_component.regexp) &&
+         regex_provider::regex_match(pathname, pathname_component.regexp) &&
+         regex_provider::regex_match(search, search_component.regexp) &&
+         regex_provider::regex_match(hash, hash_component.regexp);
 }
 
 template <url_pattern_regex::regex_concept regex_provider>
@@ -331,7 +416,8 @@ result<std::optional<url_pattern_result>> url_pattern<regex_provider>::match(
     // IMPORTANT: Not documented on the URLPattern spec, but protocol suffix ':'
     // is removed. Similar work was done on workerd:
     // https://github.com/cloudflare/workerd/blob/8620d14012513a6ce04d079e401d3becac3c67bd/src/workerd/jsg/url.c%2B%2B#L2038
-    protocol = url->get_protocol().substr(0, url->get_protocol().size() - 1);
+    auto protocol_view = url->get_protocol();
+    protocol.assign(protocol_view.data(), protocol_view.size() - 1);
     // Set username to url's username.
     username = url->get_username();
     // Set password to url's password.
@@ -349,16 +435,16 @@ result<std::optional<url_pattern_result>> url_pattern<regex_provider>::match(
     // is removed. Similar work was done on workerd:
     // https://github.com/cloudflare/workerd/blob/8620d14012513a6ce04d079e401d3becac3c67bd/src/workerd/jsg/url.c%2B%2B#L2232
     if (url->has_search()) {
-      auto view = url->get_search();
-      search = view.starts_with("?") ? url->get_search().substr(1) : view;
+      auto search_view = url->get_search();
+      search = search_view.starts_with("?") ? search_view.substr(1) : search_view;
     }
     // Set hash to url's fragment or the empty string if the value is null.
     // IMPORTANT: Not documented on the URLPattern spec, but hash prefix '#' is
     // removed. Similar work was done on workerd:
     // https://github.com/cloudflare/workerd/blob/8620d14012513a6ce04d079e401d3becac3c67bd/src/workerd/jsg/url.c%2B%2B#L2242
     if (url->has_hash()) {
-      auto view = url->get_hash();
-      hash = view.starts_with("#") ? url->get_hash().substr(1) : view;
+      auto hash_view = url->get_hash();
+      hash = hash_view.starts_with("#") ? hash_view.substr(1) : hash_view;
     }
   }
 

src/url_pattern_regex.cpp

@@ -25,11 +25,9 @@ std::optional<std::regex> std_regex_provider::create_instance(
 std::optional<std::vector<std::optional<std::string>>>
 std_regex_provider::regex_search(std::string_view input,
                                  const std::regex& pattern) {
-  std::string input_str(
-      input.begin(),
-      input.end());  // Convert string_view to string for regex_search
-  std::smatch match_result;
-  if (!std::regex_search(input_str, match_result, pattern,
+  // Use iterator-based regex_search to avoid string allocation
+  std::match_results<std::string_view::const_iterator> match_result;
+  if (!std::regex_search(input.begin(), input.end(), match_result, pattern,
                          std::regex_constants::match_any)) {
     return std::nullopt;
   }