optimize url::can_parse method

anonrig · anonrig · commit 1d8a88d437ab · 2026-03-29T14:20:56.000-04:00
diff --git a/.github/workflows/abi-check.yml b/.github/workflows/abi-check.yml
@@ -37,8 +37,21 @@ jobs:
       - name: Find latest release tag
         id: baseline
         run: |
-          # Find the most recent vX.Y.Z tag reachable from the current commit's history
-          LATEST_TAG=$(git tag --list 'v*.*.*' --sort=-version:refname | head -1)
+          # Find the most recent vX.Y.Z tag that does NOT point to the current HEAD.
+          # Excluding HEAD ensures we compare against a previous release even when a
+          # new release tag was just pushed to main alongside this workflow run.
+          CURRENT_SHA=$(git rev-parse HEAD)
+          LATEST_TAG=$(git tag --list 'v*.*.*' --sort=-version:refname | while IFS= read -r tag; do
+            TAG_SHA=$(git rev-parse "${tag}^{}" 2>/dev/null)
+            if [ "$TAG_SHA" != "$CURRENT_SHA" ]; then
+              echo "$tag"
+              break
+            fi
+          done)
+          if [ -z "$LATEST_TAG" ]; then
+            echo "No previous release tag found — cannot establish a baseline."
+            exit 1
+          fi
           echo "Latest release tag: $LATEST_TAG"
           echo "tag=$LATEST_TAG" >> "$GITHUB_OUTPUT"
 
diff --git a/include/ada/parser.h b/include/ada/parser.h
@@ -65,10 +65,12 @@ template <typename result_type = url_aggregator, bool store_values = true>
 result_type parse_url_impl(std::string_view user_input,
                            const result_type* base_url = nullptr);
 
-extern template url_aggregator parse_url_impl<url_aggregator>(
+extern template url_aggregator parse_url_impl<url_aggregator, true>(
     std::string_view user_input, const url_aggregator* base_url);
-extern template url parse_url_impl<url>(std::string_view user_input,
-                                        const url* base_url);
+extern template url_aggregator parse_url_impl<url_aggregator, false>(
+    std::string_view user_input, const url_aggregator* base_url);
+extern template url parse_url_impl<url, true>(std::string_view user_input,
+                                              const url* base_url);
 
 #if ADA_INCLUDE_URL_PATTERN
 template <url_pattern_regex::regex_concept regex_provider>
diff --git a/include/ada/url.h b/include/ada/url.h
@@ -367,6 +367,9 @@ struct url : url_base {
                                                               const ada::url *);
   friend ada::url_aggregator ada::parser::parse_url_impl<
       ada::url_aggregator, true>(std::string_view, const ada::url_aggregator *);
+  friend ada::url_aggregator
+  ada::parser::parse_url_impl<ada::url_aggregator, false>(
+      std::string_view, const ada::url_aggregator *);
 
   inline void update_unencoded_base_hash(std::string_view input);
   inline void update_base_hostname(std::string_view input);
diff --git a/src/checkers.cpp b/src/checkers.cpp
@@ -129,4 +129,42 @@ ada_really_inline constexpr bool verify_dns_length(
 
   return true;
 }
+namespace {
+
+// Returns true if port_bytes (already tab/newline-free) is a valid ASCII
+// decimal port number in the range [0, 65535].  An empty string is accepted
+// and means "no port was specified".
+ada_really_inline bool validate_port(const uint8_t* port_bytes,
+                                     size_t length) noexcept {
+  if (length == 0) return true;
+  if (length > 5) return false;  // > 99999 can never be a valid port
+  uint32_t value = 0;
+  for (size_t i = 0; i < length; ++i) {
+    if (port_bytes[i] < '0' || port_bytes[i] > '9') return false;
+    value = value * 10 + (port_bytes[i] - '0');
+  }
+  return value <= 65535;
+}
+
+// Returns true if every byte between the '[' and ']' of an IPv6 literal
+// belongs to the allowed character set: hex digits (0-9, a-f, A-F), ':', '.',
+// and '%' (zone-ID prefix).  This is a character-set check only; structural
+// validation (correct group count, '::' placement, etc.) is left to the full
+// parser.
+ada_really_inline bool validate_ipv6_inner(const uint8_t* address_bytes,
+                                           size_t length) noexcept {
+  if (length == 0) return false;
+  for (size_t i = 0; i < length; ++i) {
+    const uint8_t byte = address_bytes[i];
+    if ((byte >= '0' && byte <= '9') || (byte >= 'a' && byte <= 'f') ||
+        (byte >= 'A' && byte <= 'F') || byte == ':' || byte == '.' ||
+        byte == '%')
+      continue;
+    return false;
+  }
+  return true;
+}
+
+}  // anonymous namespace
+
 }  // namespace ada::checkers
diff --git a/src/implementation.cpp b/src/implementation.cpp
@@ -1,19 +1,192 @@
 #include "ada/implementation-inl.h"
 
+#include <optional>
 #include <string_view>
 
+#include "ada/checkers-inl.h"
+#include "ada/checkers.h"
 #include "ada/common_defs.h"
 #include "ada/parser.h"
+#include "ada/scheme.h"
+#include "ada/unicode-inl.h"
 #include "ada/url.h"
 #include "ada/url_aggregator.h"
 
 namespace ada {
 
+// ============================================================
+// Fast-path validator for can_parse.
+//
+// Validates absolute special (non-file) URLs without constructing any
+// url_aggregator object and without running the state machine.
+// Performs a single forward scan over the input bytes.
+//
+// Returns:
+//   true      -- URL is structurally valid
+//   false     -- URL is definitely invalid
+//   nullopt   -- edge case; fall through to the full parser
+//               (credentials, IDNA, IPv4/6, tabs/newlines, relative URLs, ...)
+// ============================================================
+static std::optional<bool> try_can_parse_absolute_fast(
+    std::string_view input) noexcept {
+  const uint8_t* b = reinterpret_cast<const uint8_t*>(input.data());
+  size_t len = input.size();
+
+  // -- Inline C0 whitespace trim (no allocation) --------------------------
+  while (len > 0 && b[0] <= 0x20) {
+    b++;
+    len--;
+  }
+  while (len > 0 && b[len - 1] <= 0x20) {
+    len--;
+  }
+  if (len == 0) return false;
+
+  // Tabs/newlines are rare and require tmp_buffer allocation; defer to full
+  // parser.
+  if (unicode::has_tabs_or_newline({reinterpret_cast<const char*>(b), len})) {
+    return std::nullopt;
+  }
+
+  // -- Scheme detection -----------------------------------------------------
+  if (!checkers::is_alpha(static_cast<char>(b[0]))) return false;
+
+  // Scan for ':' within the first 7 bytes. All special schemes are <= 5 chars
+  // ("https"), so any URL whose first ':' is beyond byte 6 is either
+  // non-special or relative -- both require the full parser.
+  size_t colon_pos = 0;
+  for (size_t i = 1;; ++i) {
+    if (i >= 7 || i >= len) return std::nullopt;
+    const char c = static_cast<char>(b[i]);
+    if (c == ':') {
+      colon_pos = i;
+      break;
+    }
+    if (!unicode::is_alnum_plus(c)) return false;
+  }
+
+  // Lowercase scheme bytes inline and classify via the existing perfect hash.
+  char scheme_buf[6];
+  scheme_buf[0] = static_cast<char>(b[0] | 0x20);
+  for (size_t i = 1; i < colon_pos; ++i)
+    scheme_buf[i] = static_cast<char>(b[i] | 0x20);
+
+  const ada::scheme::type scheme_type =
+      ada::scheme::get_scheme_type({scheme_buf, colon_pos});
+
+  // Only handle special, non-file schemes.
+  if (scheme_type == ada::scheme::NOT_SPECIAL) return std::nullopt;
+  if (scheme_type == ada::scheme::FILE) return std::nullopt;
+
+  // Per WHATWG, special URLs don't require "//": "http:example.com" is valid
+  // (SPECIAL_AUTHORITY_IGNORE_SLASHES just skips leading slashes and proceeds
+  // to AUTHORITY).  Defer to the inline fallback for any input without "://".
+  size_t pos = colon_pos + 1;
+  if (pos + 2 > len || b[pos] != '/' || b[pos + 1] != '/') {
+    return std::nullopt;
+  }
+  pos += 2;
+
+  // -- Single-pass authority scan --------------------------------------------
+  const size_t auth_start = pos;
+  size_t auth_end = pos;
+  size_t port_colon = SIZE_MAX;
+  bool has_x = false;
+
+  for (; auth_end < len; ++auth_end) {
+    const uint8_t c = b[auth_end];
+    if (c == '/' || c == '?' || c == '#' || c == '\\') break;
+    if (c == '@') return std::nullopt;   // credentials -> full parse
+    if (c >= 0x80) return std::nullopt;  // non-ASCII -> IDNA -> full parse
+    if (c == ':') {
+      if (port_colon == SIZE_MAX) port_colon = auth_end;
+      continue;
+    }
+    if (c == 'x' || c == 'X') has_x = true;
+  }
+
+  // IPv6 literal
+  if (auth_start < auth_end && b[auth_start] == '[') return std::nullopt;
+
+  const size_t host_end = (port_colon != SIZE_MAX) ? port_colon : auth_end;
+
+  // Empty host is invalid for special URLs.
+  if (auth_start == host_end) return false;
+
+  const char* host_ptr = reinterpret_cast<const char*>(b + auth_start);
+  const size_t host_len = host_end - auth_start;
+
+  // -- Host validation -------------------------------------------------------
+  // Bit 0x01: forbidden domain code point -> invalid.
+  // Bit 0x02: uppercase letter -> still valid (parser lowercases), not checked
+  // here.
+  const uint8_t domain_check =
+      unicode::contains_forbidden_domain_code_point_or_upper(host_ptr,
+                                                             host_len);
+  if (domain_check & 0x01) return false;
+
+  // xn-- labels require full IDNA validation.
+  if (has_x) {
+    for (size_t i = 0; i + 4 <= host_len; ++i) {
+      if ((host_ptr[i] | 0x20) == 'x' && (host_ptr[i + 1] | 0x20) == 'n' &&
+          host_ptr[i + 2] == '-' && host_ptr[i + 3] == '-') {
+        return std::nullopt;
+      }
+    }
+  }
+
+  // IPv4 detection: all-decimal-and-dot host -> try the fast IPv4 parser.
+  {
+    bool all_dec_dots = true;
+    for (size_t i = 0; i < host_len && all_dec_dots; ++i) {
+      const uint8_t c = static_cast<uint8_t>(host_ptr[i]);
+      if (c != '.' && (c < '0' || c > '9')) all_dec_dots = false;
+    }
+    if (all_dec_dots) {
+      return checkers::try_parse_ipv4_fast({host_ptr, host_len}) !=
+             checkers::ipv4_fast_fail;
+    }
+
+    // Last-significant-character heuristic for non-decimal IPv4 (hex/octal):
+    // if the last non-dot char is a digit, 'a'-'f', or 'x' the host might be
+    // an IPv4 address that the fast path can't validate -- fall through.
+    uint8_t last = 0;
+    for (size_t i = host_len; i > 0; --i) {
+      if (host_ptr[i - 1] != '.') {
+        last = static_cast<uint8_t>(host_ptr[i - 1]);
+        break;
+      }
+    }
+    const uint8_t lc = last | 0x20;
+    if ((last >= '0' && last <= '9') || (lc >= 'a' && lc <= 'f') || lc == 'x') {
+      return std::nullopt;
+    }
+  }
+
+  // -- Port validation -------------------------------------------------------
+  if (port_colon != SIZE_MAX) {
+    const uint8_t* pp = b + port_colon + 1;
+    const size_t pl = auth_end - port_colon - 1;
+    if (pl > 0) {
+      if (pl > 5) return false;  // > 99999 cannot be a valid port
+      uint32_t pv = 0;
+      for (size_t i = 0; i < pl; ++i) {
+        if (pp[i] < '0' || pp[i] > '9') return false;
+        pv = pv * 10 + (pp[i] - '0');
+      }
+      if (pv > 65535) return false;
+    }
+  }
+
+  // Path, query, and fragment are structurally always valid for can_parse --
+  // the parser would encode whatever is there.
+  return true;
+}
+
 template <class result_type>
 ada_warn_unused tl::expected<result_type, errors> parse(
     std::string_view input, const result_type* base_url) {
-  result_type u =
-      ada::parser::parse_url_impl<result_type, true>(input, base_url);
+  result_type u = ada::parser::parse_url_impl<result_type>(input, base_url);
   if (!u.is_valid) {
     return tl::unexpected(errors::type_error);
   }
@@ -49,22 +222,31 @@ std::string href_from_file(std::string_view input) {
 }
 
 bool can_parse(std::string_view input, const std::string_view* base_input) {
-  ada::url_aggregator base_aggregator;
-  ada::url_aggregator* base_pointer = nullptr;
+  // Fast path: handles the overwhelming majority of inputs -- absolute special
+  // URLs with an ASCII domain, no credentials, and no base -- with a single
+  // forward scan and zero allocations.
+  if (base_input == nullptr) {
+    if (const auto r = try_can_parse_absolute_fast(input)) {
+      return *r;
+    }
+  }
 
+  // Fallback: run the parser in validation-only mode (store_values=false),
+  // which skips all the expensive work that isn't needed to determine validity:
+  // buffer reservation, credential encoding, path normalisation, query and
+  // fragment percent-encoding.  The host is still fully validated (IDNA, IPv4,
+  // IPv6) because parse_host() must run for correctness.
+  ada::url_aggregator base_agg;
+  ada::url_aggregator* base_ptr = nullptr;
   if (base_input != nullptr) {
-    base_aggregator = ada::parser::parse_url_impl<ada::url_aggregator, false>(
+    base_agg = ada::parser::parse_url_impl<ada::url_aggregator, false>(
         *base_input, nullptr);
-    if (!base_aggregator.is_valid) {
-      return false;
-    }
-    base_pointer = &base_aggregator;
+    if (!base_agg.is_valid) return false;
+    base_ptr = &base_agg;
   }
-
-  ada::url_aggregator result =
-      ada::parser::parse_url_impl<ada::url_aggregator, false>(input,
-                                                              base_pointer);
-  return result.is_valid;
+  return ada::parser::parse_url_impl<ada::url_aggregator, false>(input,
+                                                                 base_ptr)
+      .is_valid;
 }
 
 ada_warn_unused std::string_view to_string(ada::encoding_type type) {
diff --git a/src/parser.cpp b/src/parser.cpp
@@ -7,6 +7,9 @@
 #include "ada/common_defs.h"
 #include "ada/log.h"
 #include "ada/unicode.h"
+#include "ada/url.h"
+#include "ada/url_aggregator.h"
+#include "ada/url_aggregator-inl.h"
 
 namespace ada::parser {
 
@@ -926,9 +929,11 @@ result_type parse_url_impl(std::string_view user_input,
   return url;
 }
 
-template url parse_url_impl(std::string_view user_input,
-                            const url* base_url = nullptr);
-template url_aggregator parse_url_impl(
+template url parse_url_impl<url, true>(std::string_view user_input,
+                                       const url* base_url = nullptr);
+template url_aggregator parse_url_impl<url_aggregator, true>(
+    std::string_view user_input, const url_aggregator* base_url = nullptr);
+template url_aggregator parse_url_impl<url_aggregator, false>(
     std::string_view user_input, const url_aggregator* base_url = nullptr);
 
 template <class result_type>
