make improvements

Author: anonrig

examples/bench_debug.rs

@@ -0,0 +1,28 @@
+use std::hint::black_box;
+use std::time::Instant;
+const URLS: &[&str] = &[
+    "https://www.google.com/webhp?hl=en&ictx=2",
+    "https://en.wikipedia.org/wiki/Dog#Roles_with_humans",
+    "https://www.tiktok.com/@aguyandagolden/video/7133277734310038830",
+    "https://business.twitter.com/en/help/troubleshooting/how-twitter-ads-work.html?ref=web",
+    "https://images-na.ssl-images-amazon.com/images/I/41Gc3C8UysL.css?AUI",
+    "https://www.reddit.com/?after=t3_zvz1ze",
+    "https://www.reddit.com/login/?dest=https%3A%2F%2Fwww.reddit.com%2F",
+    "postgresql://other:pass@localhost:5432/db",
+    "http://192.168.1.1",
+    "http://[2606:4700::1111]",
+];
+fn bench(label: &str, n: u32, f: impl Fn()) {
+    for _ in 0..10000 { f(); }
+    let t = Instant::now();
+    for _ in 0..n { f(); }
+    let ns = t.elapsed().as_nanos() as f64 / n as f64;
+    println!("{label}: {ns:.0} ns/iter  ({:.0} ns/url)", ns / URLS.len() as f64);
+}
+fn main() {
+    let n = 500_000u32;
+    bench("can_parse all",    n, || { for u in URLS { black_box(ada_url::Url::can_parse(black_box(u), None)); } });
+    bench("parse    all",     n, || { for u in URLS { black_box(ada_url::Url::parse(black_box(u), None)); } });
+    bench("can_parse fast7",  n, || { for u in &URLS[..7] { black_box(ada_url::Url::can_parse(black_box(u), None)); } });
+    bench("can_parse slow3",  n, || { for u in &URLS[7..] { black_box(ada_url::Url::can_parse(black_box(u), None)); } });
+}

examples/check_idna.rs

@@ -6,16 +6,24 @@ fn main() {
     let arr = v.as_array().unwrap();
     let mut wrong = 0;
     for elem in arr.iter() {
-        if elem.is_string() { continue; }
+        if elem.is_string() {
+            continue;
+        }
         let o = elem.as_object().unwrap();
         let input = o["input"].as_str().unwrap_or("");
         let expected = o.get("output").unwrap();
         let result = Idna::ascii(input);
         if expected.is_null() {
-            if !result.is_empty() { eprintln!("SHOULD_FAIL {:?} -> {:?}", input, result); wrong+=1; }
+            if !result.is_empty() {
+                eprintln!("SHOULD_FAIL {:?} -> {:?}", input, result);
+                wrong += 1;
+            }
         } else {
             let exp = expected.as_str().unwrap();
-            if result != exp { eprintln!("WRONG {:?}: got={:?} exp={:?}", input, result, exp); wrong+=1; }
+            if result != exp {
+                eprintln!("WRONG {:?}: got={:?} exp={:?}", input, result, exp);
+                wrong += 1;
+            }
         }
     }
     eprintln!("Total wrong: {}", wrong);

src/checkers.rs

@@ -66,9 +66,8 @@ pub fn is_ipv4(input: &str) -> bool {
     let last_char = b[b.len() - 1];
 
     // Quick filter: the last character must be a decimal digit, a-f, or 'x'
-    let possible = last_char.is_ascii_digit()
-        || matches!(last_char, b'a'..=b'f')
-        || last_char == b'x';
+    let possible =
+        last_char.is_ascii_digit() || matches!(last_char, b'a'..=b'f') || last_char == b'x';
     if !possible {
         return false;
     }
@@ -119,34 +118,54 @@ pub fn is_ipv4(input: &str) -> bool {
 const PATH_SIG_TABLE: [u8; 256] = {
     let mut t = [0u8; 256];
     // Needs encoding: C0 controls (0x00-0x1F), DEL (0x7F), high bytes (0x80-0xFF)
-    let mut i = 0usize; while i <= 0x1F { t[i] |= 0x01; i += 1; }
-    let mut i = 0x7Fusize; while i < 256 { t[i] |= 0x01; i += 1; }
+    let mut i = 0usize;
+    while i <= 0x1F {
+        t[i] |= 0x01;
+        i += 1;
+    }
+    let mut i = 0x7Fusize;
+    while i < 256 {
+        t[i] |= 0x01;
+        i += 1;
+    }
     // Needs encoding: specific printable ASCII chars
     let enc: &[u8] = b" \"#<>?^`{|}";
 
-    let mut i = 0; while i < enc.len() { t[enc[i] as usize] |= 0x01; i += 1; }
+    let mut i = 0;
+    while i < enc.len() {
+        t[enc[i] as usize] |= 0x01;
+        i += 1;
+    }
     // Special flags
     t[b'\\' as usize] |= 0x02; // backslash
-    t[b'.'  as usize] |= 0x04; // dot
-    t[b'%'  as usize] |= 0x08; // percent
+    t[b'.' as usize] |= 0x04; // dot
+    t[b'%' as usize] |= 0x08; // percent
     t
 };
 
-/// Compute a path-signature byte via an unrolled table lookup — branch-free.
-/// Returns a bitmask of the flags above.
+/// Compute a path-signature byte via Ada's exact 8-at-a-time unrolled lookup.
+///
+/// Ada C++ uses `for (; i + 7 < size; i += 8)` — we match that exactly.
 pub fn path_signature(input: &str) -> u8 {
     let b = input.as_bytes();
     let mut acc = 0u8;
     let mut i = 0;
-    // Unrolled 4-at-a-time — same as Ada C++ style
-    while i + 4 <= b.len() {
-        acc |= PATH_SIG_TABLE[b[i]   as usize]
-             | PATH_SIG_TABLE[b[i+1] as usize]
-             | PATH_SIG_TABLE[b[i+2] as usize]
-             | PATH_SIG_TABLE[b[i+3] as usize];
-        i += 4;
-    }
-    while i < b.len() { acc |= PATH_SIG_TABLE[b[i] as usize]; i += 1; }
+    // 8-at-a-time — Ada C++ uses this exact unroll factor
+    while i + 8 <= b.len() {
+        acc |= PATH_SIG_TABLE[b[i] as usize]
+            | PATH_SIG_TABLE[b[i + 1] as usize]
+            | PATH_SIG_TABLE[b[i + 2] as usize]
+            | PATH_SIG_TABLE[b[i + 3] as usize]
+            | PATH_SIG_TABLE[b[i + 4] as usize]
+            | PATH_SIG_TABLE[b[i + 5] as usize]
+            | PATH_SIG_TABLE[b[i + 6] as usize]
+            | PATH_SIG_TABLE[b[i + 7] as usize];
+        i += 8;
+    }
+    while i < b.len() {
+        acc |= PATH_SIG_TABLE[b[i] as usize];
+        i += 1;
+    }
     acc
 }
 

src/helpers.rs

@@ -17,8 +17,8 @@ use crate::checkers::{
 };
 use crate::scheme::SchemeType;
 use crate::unicode::{
-    is_c0_control_or_space, is_double_dot_path_segment,
-    is_single_dot_path_segment, percent_encode_append,
+    is_c0_control_or_space, is_double_dot_path_segment, is_single_dot_path_segment,
+    percent_encode_append,
 };
 
 // ---------------------------------------------------------------------------
@@ -66,6 +66,7 @@ pub fn remove_ascii_tab_or_newline(s: &mut String) {
 /// Trim leading and trailing C0 control characters and ASCII space.
 /// Returns a `&str` slice into the original — **zero allocation**.
 #[inline]
+#[allow(dead_code)]
 pub fn trim_c0_whitespace(s: &str) -> &str {
     let start = s
         .as_bytes()

src/idna.rs

@@ -39,9 +39,13 @@ mod tests {
 
     #[test]
     #[cfg(feature = "std")]
-    fn unicode_works() { assert_eq!(Idna::unicode("xn--meagefactory-m9a.ca"), "meßagefactory.ca"); }
+    fn unicode_works() {
+        assert_eq!(Idna::unicode("xn--meagefactory-m9a.ca"), "meßagefactory.ca");
+    }
 
     #[test]
     #[cfg(feature = "std")]
-    fn ascii_works() { assert_eq!(Idna::ascii("meßagefactory.ca"), "xn--meagefactory-m9a.ca"); }
+    fn ascii_works() {
+        assert_eq!(Idna::ascii("meßagefactory.ca"), "xn--meagefactory-m9a.ca");
+    }
 }