make some improvements

Author: anonrig

examples/wpt_cost.rs

@@ -0,0 +1,62 @@
+use std::time::Instant;
+
+fn main() {
+    let raw = std::fs::read_to_string("tests/wpt/urltestdata.json").unwrap();
+    let data: serde_json::Value = serde_json::from_str(&raw).unwrap();
+    let entries: Vec<_> = data.as_array().unwrap().iter()
+        .filter_map(|e| e.as_object())
+        .filter_map(|o| {
+            let input = o.get("input")?.as_str()?;
+            let base = o.get("base").and_then(|b| b.as_str()).unwrap_or("");
+            Some((input.to_string(), base.to_string()))
+        })
+        .collect();
+
+    let n = 2000u32;
+    // warm up
+    for _ in 0..200 {
+        for (inp, base) in &entries {
+            let b = if base.is_empty() { None } else { Some(base.as_str()) };
+            let _ = ada_url::Url::parse(inp.as_str(), b);
+        }
+    }
+
+    // Timed run
+    let t = Instant::now();
+    for _ in 0..n {
+        for (inp, base) in &entries {
+            let b = if base.is_empty() { None } else { Some(std::hint::black_box(base.as_str())) };
+            let _ = std::hint::black_box(ada_url::Url::parse(std::hint::black_box(inp.as_str()), b));
+        }
+    }
+    let elapsed = t.elapsed();
+    let per_iter = elapsed.as_nanos() as f64 / n as f64;
+    let per_url  = per_iter / entries.len() as f64;
+    println!("Total per iteration: {:.1}µs  ({} entries, {:.1}ns/url)", per_iter/1000.0, entries.len(), per_url);
+
+    // Now simulate the benchmark (with base re-parse like the bench does)
+    let t2 = Instant::now();
+    for _ in 0..n {
+        let mut href_size = 0usize;
+        for (input, base) in &entries {
+            let parsed = if !base.is_empty() {
+                match ada_url::Url::parse(std::hint::black_box(base.as_str()), None::<&str>) {
+                    Ok(base_url) => {
+                        let base_href = base_url.href().to_owned();
+                        ada_url::Url::parse(std::hint::black_box(input.as_str()), Some(base_href.as_str()))
+                    }
+                    Err(_) => continue,
+                }
+            } else {
+                ada_url::Url::parse(std::hint::black_box(input.as_str()), None::<&str>)
+            };
+            if let Ok(url) = parsed { href_size += url.href().len(); }
+        }
+        std::hint::black_box(href_size);
+    }
+    let e2 = t2.elapsed();
+    let per_bench_iter = e2.as_nanos() as f64 / n as f64;
+    println!("Benchmark simulation:  {:.1}µs per iteration", per_bench_iter/1000.0);
+    println!("Overhead from double-parse: {:.1}µs ({:.1}%)", (per_bench_iter - per_iter)/1000.0, (per_bench_iter - per_iter) / per_iter * 100.0);
+}
+// This won't compile as-is, use a separate test

src/checkers.rs

@@ -176,6 +176,106 @@ pub fn path_signature(input: &str) -> u8 {
     }
 }
 
+/// Full WHATWG IPv4 address parser — handles decimal, octal (leading 0),
+/// hex (0x/0X), and 1–4 dot-separated parts (e.g. "127.1", "0xc0a80101").
+///
+/// Returns `Some(packed_u32)` on success, `None` for invalid input.
+/// This is used by `try_parse_absolute_fast` to normalise IPv4 addresses in-place.
+pub fn parse_ipv4_address(input: &str) -> Option<u32> {
+    let input = input.trim_end_matches('.');
+    if input.is_empty() {
+        return None;
+    }
+    let mut parts = 0usize; // dot-separated parts consumed so far
+    let mut ipv4: u64 = 0;
+    let mut rem = input;
+
+    loop {
+        if parts >= 4 || rem.is_empty() {
+            break;
+        }
+        let b = rem.as_bytes();
+
+        // Determine radix and parse one part
+        let (val, consumed) = if b.len() >= 2 && b[0] == b'0' && (b[1] == b'x' || b[1] == b'X') {
+            // Hexadecimal
+            if b.len() == 2 || b[2] == b'.' {
+                (0u64, 2usize)
+            } else {
+                let (v, c) = parse_uint_raw(&rem[2..], 16)?;
+                (v, 2 + c)
+            }
+        } else if b[0] == b'0' && b.len() > 1 && b[1] >= b'0' && b[1] <= b'9' {
+            // Octal
+            let (v, c) = parse_uint_raw(&rem[1..], 8)?;
+            (v, 1 + c)
+        } else {
+            // Decimal
+            parse_uint_raw(rem, 10)?
+        };
+
+        rem = &rem[consumed..];
+
+        if rem.is_empty() {
+            // Final (possibly multi-octet) part
+            let bits = 32u32.wrapping_sub(parts as u32 * 8);
+            let max = if bits >= 64 { u64::MAX } else { 1u64 << bits };
+            if val >= max {
+                return None; // overflow
+            }
+            ipv4 = (ipv4 << bits) | val;
+            parts += 1;
+            break;
+        } else {
+            // Intermediate part — must be a single octet ≤ 255 followed by '.'
+            if val > 255 || rem.as_bytes()[0] != b'.' {
+                return None;
+            }
+            ipv4 = (ipv4 << 8) | val;
+            rem = &rem[1..]; // skip '.'
+            parts += 1;
+        }
+    }
+
+    if !rem.is_empty() || parts == 0 {
+        return None;
+    }
+    Some(ipv4 as u32)
+}
+
+/// Parse an unsigned integer of the given radix from the start of `s`.
+/// Returns `(value, bytes_consumed)` or `None` if no digits were found.
+#[inline]
+fn parse_uint_raw(s: &str, radix: u64) -> Option<(u64, usize)> {
+    let b = s.as_bytes();
+    if b.is_empty() {
+        return None;
+    }
+    let mut v = 0u64;
+    let mut c = 0usize;
+    for &byte in b {
+        let d = match radix {
+            16 => match byte {
+                b'0'..=b'9' => (byte - b'0') as u64,
+                b'a'..=b'f' => (byte - b'a' + 10) as u64,
+                b'A'..=b'F' => (byte - b'A' + 10) as u64,
+                _ => break,
+            },
+            8 => match byte {
+                b'0'..=b'7' => (byte - b'0') as u64,
+                _ => break,
+            },
+            _ => match byte {
+                b'0'..=b'9' => (byte - b'0') as u64,
+                _ => break,
+            },
+        };
+        v = v.checked_mul(radix)?.checked_add(d)?;
+        c += 1;
+    }
+    if c == 0 { None } else { Some((v, c)) }
+}
+
 /// Check that the domain name length and label lengths are within DNS limits.
 pub fn verify_dns_length(input: &str) -> bool {
     let s = input.strip_suffix('.').unwrap_or(input);

src/lib.rs

@@ -218,6 +218,28 @@ impl Url {
     where
         Input: AsRef<str>,
     {
+        let input_str = input.as_ref();
+
+        // Optimised path: when a base is supplied but the input is itself an
+        // absolute URL, the parsed base is never consulted for resolution.
+        // Instead of fully parsing the base string into a `Url` (which
+        // allocates a String buffer), validate it with the zero-allocation
+        // validator.  The spec still requires failure when the base is invalid,
+        // so we check that too — but without heap allocation.
+        if let Some(b) = base
+            && let Some(url) = parser::try_parse_absolute_fast(input_str)
+        {
+            // Validate base cheaply: try the zero-alloc fast checker first,
+            // fall back to the full zero-alloc validator for edge cases.
+            let base_ok =
+                parser::try_validate_absolute_fast(b).is_some() || validator::can_parse_no_base(b);
+            return if base_ok {
+                Ok(url)
+            } else {
+                Err(ParseUrlError { input })
+            };
+        }
+
         let base_url = if let Some(b) = base {
             match parser::parse_url(b, None) {
                 Some(u) if u.is_valid => Some(u),
@@ -227,12 +249,33 @@ impl Url {
             None
         };
 
-        match parser::parse_url(input.as_ref(), base_url.as_ref()) {
+        match parser::parse_url(input_str, base_url.as_ref()) {
             Some(u) if u.is_valid => Ok(u),
             _ => Err(ParseUrlError { input }),
         }
     }
 
+    /// Parse `input` relative to an already-parsed `base` URL.
+    ///
+    /// This is more efficient than [`Url::parse`] with a base string because the
+    /// base URL is **not** re-parsed — use this in hot loops where the same base
+    /// is reused across many inputs (e.g. the WPT URL benchmark pattern).
+    ///
+    /// Returns `None` when either `base` is invalid or `input` cannot be resolved.
+    #[must_use]
+    pub fn parse_with_base<Input>(input: Input, base: &Url) -> Option<Self>
+    where
+        Input: AsRef<str>,
+    {
+        if !base.is_valid {
+            return None;
+        }
+        match parser::parse_url(input.as_ref(), Some(base)) {
+            Some(u) if u.is_valid => Some(u),
+            _ => None,
+        }
+    }
+
     /// Returns `true` when `input` can be parsed as a valid URL.
     ///
     /// When `base` is `None` this uses a zero-allocation fast-path validator
@@ -1682,6 +1725,35 @@ impl Url {
             self.buffer.push_str(input);
             return;
         }
+        // Fast append: path already set, no dot-segments, no encoding, AND
+        // no search/fragment follows the path in the buffer.  Only then can
+        // we safely push directly to the buffer end without displacing query
+        // or fragment bytes that sit after the current path.
+        //
+        // Extra guard: when the current path is exactly "/" appending "/"
+        // + input would produce "//input".  `update_base_pathname("//...")` has
+        // a side-effect of inserting "/." for authority-less URLs; bypassing it
+        // would produce a wrong href (e.g. "non-spec://path" instead of
+        // "non-spec:/.//path").  Avoid fast_append for this edge case.
+        let fast_append = trivial
+            && !self.is_at_path()
+            && !input.starts_with("..")
+            && !input.starts_with('.')
+            && self.components.search_start == OMITTED
+            && self.components.hash_start == OMITTED
+            && self.pathname() != "/";
+        if fast_append {
+            let added = (1 + input.len()) as u32;
+            self.buffer.push('/');
+            self.buffer.push_str(input);
+            if self.components.search_start != OMITTED {
+                self.components.search_start += added;
+            }
+            if self.components.hash_start != OMITTED {
+                self.components.hash_start += added;
+            }
+            return;
+        }
         let mut new_path = if self.is_at_path() {
             String::new()
         } else {