Merge branch 'main' into patch-1

Author: tisonkun

.github/workflows/main.yml

@@ -95,6 +95,7 @@ jobs:
             {
               echo "leak:dyld4::RuntimeState"
               echo "leak:fetchInitializingClassList"
+              echo "leak:std::sys::pal::unix::stack_overflow::imp::init"
             } > suppressions.txt
             export LSAN_OPTIONS="suppressions=$(pwd)/suppressions.txt"
           fi

LICENSE-MIT

@@ -1,4 +1,4 @@
-Copyright (c) 2013-2022 The rust-url developers
+Copyright (c) 2013-2025 The rust-url developers
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

data-url/src/lib.rs

@@ -124,7 +124,7 @@ impl<'a> DataUrl<'a> {
 /// The URL’s fragment identifier (after `#`)
 pub struct FragmentIdentifier<'a>(&'a str);
 
-impl<'a> FragmentIdentifier<'a> {
+impl FragmentIdentifier<'_> {
     /// Like in a parsed URL
     pub fn to_percent_encoded(&self) -> String {
         let mut string = String::new();
@@ -165,10 +165,10 @@ fn pretend_parse_data_url(input: &str) -> Option<&str> {
         let mut iter = bytes
             .by_ref()
             .filter(|&byte| !matches!(byte, b'\t' | b'\n' | b'\r'));
-        require!(iter.next()?.to_ascii_lowercase() == b'd');
-        require!(iter.next()?.to_ascii_lowercase() == b'a');
-        require!(iter.next()?.to_ascii_lowercase() == b't');
-        require!(iter.next()?.to_ascii_lowercase() == b'a');
+        require!(iter.next()?.eq_ignore_ascii_case(&b'd'));
+        require!(iter.next()?.eq_ignore_ascii_case(&b'a'));
+        require!(iter.next()?.eq_ignore_ascii_case(&b't'));
+        require!(iter.next()?.eq_ignore_ascii_case(&b'a'));
         require!(iter.next()? == b':');
     }
     let bytes_consumed = left_trimmed.len() - bytes.len();
@@ -256,10 +256,10 @@ fn remove_base64_suffix(s: &str) -> Option<&str> {
 
         require!(iter.next()? == b'4');
         require!(iter.next()? == b'6');
-        require!(iter.next()?.to_ascii_lowercase() == b'e');
-        require!(iter.next()?.to_ascii_lowercase() == b's');
-        require!(iter.next()?.to_ascii_lowercase() == b'a');
-        require!(iter.next()?.to_ascii_lowercase() == b'b');
+        require!(iter.next()?.eq_ignore_ascii_case(&b'e'));
+        require!(iter.next()?.eq_ignore_ascii_case(&b's'));
+        require!(iter.next()?.eq_ignore_ascii_case(&b'a'));
+        require!(iter.next()?.eq_ignore_ascii_case(&b'b'));
         require!(iter.skip_while(|&byte| byte == b' ').next()? == b';');
     }
     Some(&s[..bytes.len()])

form_urlencoded/src/lib.rs

@@ -104,7 +104,7 @@ pub struct ParseIntoOwned<'a> {
     inner: Parse<'a>,
 }
 
-impl<'a> Iterator for ParseIntoOwned<'a> {
+impl Iterator for ParseIntoOwned<'_> {
     type Item = (String, String);
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -195,7 +195,7 @@ impl Target for String {
     type Finished = Self;
 }
 
-impl<'a> Target for &'a mut String {
+impl Target for &mut String {
     fn as_mut_string(&mut self) -> &mut String {
         self
     }

idna/src/punycode.rs

@@ -277,7 +277,7 @@ where
     phantom: PhantomData<C>,
 }
 
-impl<'a, T: PunycodeCodeUnit + Copy, C: PunycodeCaller> Iterator for Decode<'a, T, C> {
+impl<T: PunycodeCodeUnit + Copy, C: PunycodeCaller> Iterator for Decode<'_, T, C> {
     type Item = char;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -309,7 +309,7 @@ impl<'a, T: PunycodeCodeUnit + Copy, C: PunycodeCaller> Iterator for Decode<'a,
     }
 }
 
-impl<'a, T: PunycodeCodeUnit + Copy, C: PunycodeCaller> ExactSizeIterator for Decode<'a, T, C> {
+impl<T: PunycodeCodeUnit + Copy, C: PunycodeCaller> ExactSizeIterator for Decode<'_, T, C> {
     fn len(&self) -> usize {
         self.len - self.position
     }

percent_encoding/src/lib.rs

@@ -181,7 +181,7 @@ impl<'a> Iterator for PercentEncode<'a> {
     }
 }
 
-impl<'a> fmt::Display for PercentEncode<'a> {
+impl fmt::Display for PercentEncode<'_> {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         for c in (*self).clone() {
             formatter.write_str(c)?
@@ -257,7 +257,7 @@ fn after_percent_sign(iter: &mut slice::Iter<'_, u8>) -> Option<u8> {
     Some(h as u8 * 0x10 + l as u8)
 }
 
-impl<'a> Iterator for PercentDecode<'a> {
+impl Iterator for PercentDecode<'_> {
     type Item = u8;
 
     fn next(&mut self) -> Option<u8> {

url/Cargo.toml

@@ -28,7 +28,7 @@ wasm-bindgen-test = "0.3"
 form_urlencoded = { version = "1.2.1", path = "../form_urlencoded", default-features = false, features = ["alloc"] }
 idna = { version = "1.0.3", path = "../idna", default-features = false, features = ["alloc", "compiled_data"] }
 percent-encoding = { version = "2.3.1", path = "../percent_encoding", default-features = false, features = ["alloc"] }
-serde = { version = "1.0", optional = true, features = ["derive"] }
+serde = { version = "1.0", optional = true, features = ["derive"], default-features = false }
 
 [features]
 default = ["std"]

url/benches/parse_url.rs

@@ -19,13 +19,27 @@ fn long(bench: &mut Bencher) {
     bench.iter(|| black_box(url).parse::<Url>().unwrap());
 }
 
+fn fragment(bench: &mut Bencher) {
+    let url = "https://example.com/parkbench?tre=es&st=uff#fragment";
+
+    bench.bytes = url.len() as u64;
+    bench.iter(|| black_box(url).parse::<Url>().unwrap());
+}
+
 fn plain(bench: &mut Bencher) {
     let url = "https://example.com/";
 
     bench.bytes = url.len() as u64;
     bench.iter(|| black_box(url).parse::<Url>().unwrap());
 }
 
+fn port(bench: &mut Bencher) {
+    let url = "https://example.com:8080";
+
+    bench.bytes = url.len() as u64;
+    bench.iter(|| black_box(url).parse::<Url>().unwrap());
+}
+
 fn hyphen(bench: &mut Bencher) {
     let url = "https://hyphenated-example.com/";
 
@@ -82,11 +96,26 @@ fn punycode_rtl(bench: &mut Bencher) {
     bench.iter(|| black_box(url).parse::<Url>().unwrap());
 }
 
+fn url_to_file_path(bench: &mut Bencher) {
+    let url = if cfg!(windows) {
+        "file:///C:/dir/next_dir/sub_sub_dir/testing/testing.json"
+    } else {
+        "file:///data/dir/next_dir/sub_sub_dir/testing/testing.json"
+    };
+    let url = url.parse::<Url>().unwrap();
+
+    bench.iter(|| {
+        black_box(url.to_file_path().unwrap());
+    });
+}
+
 benchmark_group!(
     benches,
     short,
     long,
+    fragment,
     plain,
+    port,
     hyphen,
     leading_digit,
     unicode_mixed,
@@ -95,5 +124,6 @@ benchmark_group!(
     punycode_ltr,
     unicode_rtl,
     punycode_rtl,
+    url_to_file_path
 );
 benchmark_main!(benches);

url/src/host.rs

@@ -64,7 +64,7 @@ pub enum Host<S = String> {
     Ipv6(Ipv6Addr),
 }
 
-impl<'a> Host<&'a str> {
+impl Host<&str> {
     /// Return a copy of `self` that owns an allocated `String` but does not borrow an `&Url`.
     pub fn to_owned(&self) -> Host<String> {
         match *self {

url/src/lib.rs

@@ -1497,7 +1497,6 @@ impl Url {
     /// # }
     /// # run().unwrap();
     /// ```
-
     #[inline]
     pub fn query_pairs(&self) -> form_urlencoded::Parse<'_> {
         form_urlencoded::parse(self.query().unwrap_or("").as_bytes())
@@ -1560,7 +1559,7 @@ impl Url {
     /// # fn run() -> Result<(), ParseError> {
     /// let mut url = Url::parse("https://example.com/data.csv")?;
     /// assert_eq!(url.as_str(), "https://example.com/data.csv");
-
+    ///
     /// url.set_fragment(Some("cell=4,1-6,2"));
     /// assert_eq!(url.as_str(), "https://example.com/data.csv#cell=4,1-6,2");
     /// assert_eq!(url.fragment(), Some("cell=4,1-6,2"));
@@ -2679,8 +2678,7 @@ impl Url {
             fragment_start,
         };
         if cfg!(debug_assertions) {
-            url.check_invariants()
-                .map_err(|reason| Error::custom(reason))?
+            url.check_invariants().map_err(Error::custom)?
         }
         Ok(url)
     }
@@ -2727,7 +2725,26 @@ impl Url {
                 _ => return Err(()),
             };
 
-            return file_url_segments_to_pathbuf(host, segments);
+            let str_len = self.as_str().len();
+            let estimated_capacity = if cfg!(target_os = "redox") {
+                let scheme_len = self.scheme().len();
+                let file_scheme_len = "file".len();
+                // remove only // because it still has file:
+                if scheme_len < file_scheme_len {
+                    let scheme_diff = file_scheme_len - scheme_len;
+                    (str_len + scheme_diff).saturating_sub(2)
+                } else {
+                    let scheme_diff = scheme_len - file_scheme_len;
+                    str_len.saturating_sub(scheme_diff + 2)
+                }
+            } else if cfg!(windows) {
+                // remove scheme: - has posssible \\ for hostname
+                str_len.saturating_sub(self.scheme().len() + 1)
+            } else {
+                // remove scheme://
+                str_len.saturating_sub(self.scheme().len() + 3)
+            };
+            return file_url_segments_to_pathbuf(estimated_capacity, host, segments);
         }
         Err(())
     }
@@ -2897,7 +2914,7 @@ impl<'de> serde::Deserialize<'de> for Url {
 
         struct UrlVisitor;
 
-        impl<'de> Visitor<'de> for UrlVisitor {
+        impl Visitor<'_> for UrlVisitor {
             type Value = Url;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -3037,6 +3054,7 @@ fn path_to_file_url_segments_windows(
     any(unix, target_os = "redox", target_os = "wasi", target_os = "hermit")
 ))]
 fn file_url_segments_to_pathbuf(
+    estimated_capacity: usize,
     host: Option<&str>,
     segments: str::Split<'_, char>,
 ) -> Result<PathBuf, ()> {
@@ -3048,17 +3066,16 @@ fn file_url_segments_to_pathbuf(
     use std::os::hermit::ffi::OsStrExt;
     #[cfg(any(unix, target_os = "redox"))]
     use std::os::unix::prelude::OsStrExt;
-    use std::path::PathBuf;
 
     if host.is_some() {
         return Err(());
     }
 
-    let mut bytes = if cfg!(target_os = "redox") {
-        b"file:".to_vec()
-    } else {
-        Vec::new()
-    };
+    let mut bytes = Vec::new();
+    bytes.try_reserve(estimated_capacity).map_err(|_| ())?;
+    if cfg!(target_os = "redox") {
+        bytes.extend(b"file:");
+    }
 
     for segment in segments {
         bytes.push(b'/');
@@ -3090,22 +3107,27 @@ fn file_url_segments_to_pathbuf(
 
 #[cfg(all(feature = "std", windows))]
 fn file_url_segments_to_pathbuf(
+    estimated_capacity: usize,
     host: Option<&str>,
     segments: str::Split<char>,
 ) -> Result<PathBuf, ()> {
-    file_url_segments_to_pathbuf_windows(host, segments)
+    file_url_segments_to_pathbuf_windows(estimated_capacity, host, segments)
 }
 
 // Build this unconditionally to alleviate https://github.com/servo/rust-url/issues/102
 #[cfg(feature = "std")]
 #[cfg_attr(not(windows), allow(dead_code))]
 fn file_url_segments_to_pathbuf_windows(
+    estimated_capacity: usize,
     host: Option<&str>,
     mut segments: str::Split<'_, char>,
 ) -> Result<PathBuf, ()> {
-    use percent_encoding::percent_decode;
-    let mut string = if let Some(host) = host {
-        r"\\".to_owned() + host
+    use percent_encoding::percent_decode_str;
+    let mut string = String::new();
+    string.try_reserve(estimated_capacity).map_err(|_| ())?;
+    if let Some(host) = host {
+        string.push_str(r"\\");
+        string.push_str(host);
     } else {
         let first = segments.next().ok_or(())?;
 
@@ -3115,7 +3137,7 @@ fn file_url_segments_to_pathbuf_windows(
                     return Err(());
                 }
 
-                first.to_owned()
+                string.push_str(first);
             }
 
             4 => {
@@ -3127,7 +3149,8 @@ fn file_url_segments_to_pathbuf_windows(
                     return Err(());
                 }
 
-                first[0..1].to_owned() + ":"
+                string.push_str(&first[0..1]);
+                string.push(':');
             }
 
             _ => return Err(()),
@@ -3138,11 +3161,20 @@ fn file_url_segments_to_pathbuf_windows(
         string.push('\\');
 
         // Currently non-unicode windows paths cannot be represented
-        match String::from_utf8(percent_decode(segment.as_bytes()).collect()) {
+        match percent_decode_str(segment).decode_utf8() {
             Ok(s) => string.push_str(&s),
             Err(..) => return Err(()),
         }
     }
+    // ensure our estimated capacity was good
+    if cfg!(test) {
+        debug_assert!(
+            string.len() <= estimated_capacity,
+            "len: {}, capacity: {}",
+            string.len(),
+            estimated_capacity
+        );
+    }
     let path = PathBuf::from(string);
     debug_assert!(
         path.is_absolute(),
@@ -3182,7 +3214,7 @@ impl<'a> form_urlencoded::Target for UrlQuery<'a> {
     type Finished = &'a mut Url;
 }
 
-impl<'a> Drop for UrlQuery<'a> {
+impl Drop for UrlQuery<'_> {
     fn drop(&mut self) {
         if let Some(url) = self.url.take() {
             url.restore_already_parsed_fragment(self.fragment.take())