no_std support for the url crate

.github/workflows/main.yml

@@ -33,6 +33,8 @@ jobs:
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ matrix.rust }}
+      # Add toolchain for no_std tests
+      - run: rustup target add aarch64-unknown-none
       - run: cargo build --all-targets
         # Run tests
       - name: Run tests
@@ -49,6 +51,8 @@ jobs:
         run: cargo test --test debugger_visualizer --features "url/serde,url/debugger_visualizer" -- --test-threads=1
       - name: Test `no_std` support
         run: cargo test --no-default-features --features=alloc
+      - name: Build `aarch64-unknown-none` with `no_std`
+        run: cargo +nightly build -Zbuild-std=core,alloc --target aarch64-unknown-none -v --release
 
   WASM:
     runs-on: ubuntu-latest

idna/src/uts46.rs

@@ -453,7 +453,7 @@ impl Idna {
             return Errors::default();
         }
         let mut errors = processing(domain, self.config, &mut self.normalized, out);
-        self.output = std::mem::replace(out, String::with_capacity(out.len()));
+        self.output = core::mem::replace(out, String::with_capacity(out.len()));
         let mut first = true;
         for label in self.output.split('.') {
             if !first {

url/Cargo.toml

@@ -28,13 +28,15 @@ debugger_test = "0.1"
 debugger_test_parser = "0.1"
 
 [dependencies]
-form_urlencoded = { version = "1.1.0", path = "../form_urlencoded" }
-idna = { version = "0.3.0", path = "../idna" }
-percent-encoding = { version = "2.2.0", path = "../percent_encoding" }
+form_urlencoded = { version = "1.1.0", path = "../form_urlencoded", default-features = false }
+idna = { version = "0.3.0", path = "../idna", default-features = false  }
+percent-encoding = { version = "2.2.0", path = "../percent_encoding", default-features = false }
 serde = {version = "1.0", optional = true, features = ["derive"]}
 
 [features]
-default = []
+default = ["std"]
+std = ["idna/std", "percent-encoding/std", "form_urlencoded/std", "alloc"]
+alloc = []
 # UNSTABLE FEATURES (requires Rust nightly)
 # Enable to use the #[debugger_visualizer] attribute.
 debugger_visualizer = []

url/src/host.rs

@@ -6,8 +6,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::cmp;
-use std::fmt::{self, Formatter};
+use alloc::{
+    borrow::ToOwned,
+    string::{String, ToString},
+    vec::Vec,
+};
+#[cfg(not(feature = "std"))]
+use core::net::{Ipv4Addr, Ipv6Addr};
+use core::{
+    cmp,
+    fmt::{self, Formatter},
+};
+#[cfg(feature = "std")]
 use std::net::{Ipv4Addr, Ipv6Addr};
 
 use percent_encoding::{percent_decode, utf8_percent_encode, CONTROLS};

url/src/lib.rs

@@ -127,27 +127,47 @@ url = { version = "2", features = ["serde"] }
     feature(debugger_visualizer),
     debugger_visualizer(natvis_file = "../../debug_metadata/url.natvis")
 )]
+#![no_std]
+#![cfg_attr(not(feature = "std"), feature(ip_in_core))]
 
 pub use form_urlencoded;
 
+// For forwards compatibility
+#[cfg(feature = "std")]
+extern crate std;
+
+#[macro_use]
+extern crate alloc;
+
+#[cfg(not(feature = "alloc"))]
+compile_error!("the `alloc` feature must be enabled");
+
 #[cfg(feature = "serde")]
 extern crate serde;
 
 use crate::host::HostInternal;
-use crate::parser::{to_u32, Context, Parser, SchemeType, PATH_SEGMENT, USERINFO};
-use percent_encoding::{percent_decode, percent_encode, utf8_percent_encode};
-use std::borrow::Borrow;
-use std::cmp;
-use std::fmt::{self, Write};
-use std::hash;
-use std::io;
-use std::mem;
-use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
-use std::ops::{Range, RangeFrom, RangeTo};
-use std::path::{Path, PathBuf};
-use std::str;
-
-use std::convert::TryFrom;
+use crate::parser::{to_u32, Context, Parser, SchemeType, USERINFO};
+use alloc::borrow::ToOwned;
+use alloc::string::{String, ToString};
+use core::borrow::Borrow;
+use core::cmp;
+use core::convert::TryFrom;
+use core::fmt::{self, Write};
+use core::hash;
+use core::mem;
+#[cfg(not(feature = "std"))]
+use core::net::IpAddr;
+use core::ops::{Range, RangeFrom, RangeTo};
+use core::str;
+use percent_encoding::utf8_percent_encode;
+#[cfg(feature = "std")]
+use std::net::IpAddr;
+#[cfg(feature = "std")]
+use std::{
+    io,
+    net::{SocketAddr, ToSocketAddrs},
+    path::{Path, PathBuf},
+};
 
 pub use crate::host::Host;
 pub use crate::origin::{OpaqueOrigin, Origin};
@@ -1237,10 +1257,11 @@ impl Url {
     ///     })
     /// }
     /// ```
+    #[cfg(feature = "std")]
     pub fn socket_addrs(
         &self,
         default_port_number: impl Fn() -> Option<u16>,
-    ) -> io::Result<Vec<SocketAddr>> {
+    ) -> io::Result<alloc::vec::Vec<SocketAddr>> {
         // Note: trying to avoid the Vec allocation by returning `impl AsRef<[SocketAddr]>`
         // causes borrowck issues because the return value borrows `default_port_number`:
         //
@@ -1249,6 +1270,7 @@ impl Url {
         // > This RFC proposes that *all* type parameters are considered in scope
         // > for `impl Trait` in return position
 
+        // TODO: Return custom error type to support no_std
         fn io_result<T>(opt: Option<T>, message: &str) -> io::Result<T> {
             opt.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, message))
         }
@@ -1310,9 +1332,23 @@ impl Url {
     ///
     /// ```
     /// use url::Url;
-    /// # use std::error::Error;
     ///
-    /// # fn run() -> Result<(), Box<dyn Error>> {
+    /// # use url::ParseError;
+    /// # #[derive(Debug)]
+    /// # /// A simple wrapper error struct for `no_std` support
+    /// # struct TestError;
+    /// # impl From<ParseError> for TestError {
+    /// #   fn from(value: ParseError) -> Self {
+    /// #       TestError {}
+    /// #   }
+    /// # }
+    /// # impl From<&str> for TestError {
+    /// #   fn from(value: &str) -> Self {
+    /// #       TestError {}
+    /// #   }
+    /// # }
+    ///
+    /// # fn run() -> Result<(), TestError> {
     /// let url = Url::parse("https://example.com/foo/bar")?;
     /// let mut path_segments = url.path_segments().ok_or_else(|| "cannot be base")?;
     /// assert_eq!(path_segments.next(), Some("foo"));
@@ -1717,9 +1753,22 @@ impl Url {
     ///
     /// ```
     /// use url::Url;
-    /// # use std::error::Error;
+    /// # use url::ParseError;
+    /// # #[derive(Debug)]
+    /// # /// A simple wrapper error struct for `no_std` support
+    /// # struct TestError;
+    /// # impl From<ParseError> for TestError {
+    /// #   fn from(value: ParseError) -> Self {
+    /// #       TestError {}
+    /// #   }
+    /// # }
+    /// # impl From<&str> for TestError {
+    /// #   fn from(value: &str) -> Self {
+    /// #       TestError {}
+    /// #   }
+    /// # }
     ///
-    /// # fn run() -> Result<(), Box<dyn Error>> {
+    /// # fn run() -> Result<(), TestError> {
     /// let mut url = Url::parse("ssh://example.net:2048/")?;
     ///
     /// url.set_port(Some(4096)).map_err(|_| "cannot be base")?;
@@ -1736,9 +1785,22 @@ impl Url {
     ///
     /// ```rust
     /// use url::Url;
-    /// # use std::error::Error;
+    /// # use url::ParseError;
+    /// # #[derive(Debug)]
+    /// # /// A simple wrapper error struct for `no_std` support
+    /// # struct TestError;
+    /// # impl From<ParseError> for TestError {
+    /// #   fn from(value: ParseError) -> Self {
+    /// #       TestError {}
+    /// #   }
+    /// # }
+    /// # impl From<&str> for TestError {
+    /// #   fn from(value: &str) -> Self {
+    /// #       TestError {}
+    /// #   }
+    /// # }
     ///
-    /// # fn run() -> Result<(), Box<dyn Error>> {
+    /// # fn run() -> Result<(), TestError> {
     /// let mut url = Url::parse("https://example.org/")?;
     ///
     /// url.set_port(Some(443)).map_err(|_| "cannot be base")?;
@@ -2419,7 +2481,12 @@ impl Url {
     /// # run().unwrap();
     /// # }
     /// ```
-    #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))]
+    ///
+    /// This method is only available if the `std` Cargo feature is enabled.
+    #[cfg(all(
+        feature = "std",
+        any(unix, windows, target_os = "redox", target_os = "wasi")
+    ))]
     #[allow(clippy::result_unit_err)]
     pub fn from_file_path<P: AsRef<Path>>(path: P) -> Result<Url, ()> {
         let mut serialization = "file://".to_owned();
@@ -2456,7 +2523,12 @@ impl Url {
     ///
     /// Note that `std::path` does not consider trailing slashes significant
     /// and usually does not include them (e.g. in `Path::parent()`).
-    #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))]
+    ///
+    /// This method is only available if the `std` Cargo feature is enabled.
+    #[cfg(all(
+        feature = "std",
+        any(unix, windows, target_os = "redox", target_os = "wasi")
+    ))]
     #[allow(clippy::result_unit_err)]
     pub fn from_directory_path<P: AsRef<Path>>(path: P) -> Result<Url, ()> {
         let mut url = Url::from_file_path(path)?;
@@ -2572,8 +2644,13 @@ impl Url {
     /// or if `Path::new_opt()` returns `None`.
     /// (That is, if the percent-decoded path contains a NUL byte or,
     /// for a Windows path, is not UTF-8.)
+    ///
+    /// This method is only available if the `std` Cargo feature is enabled.
     #[inline]
-    #[cfg(any(unix, windows, target_os = "redox", target_os = "wasi"))]
+    #[cfg(all(
+        feature = "std",
+        any(unix, windows, target_os = "redox", target_os = "wasi")
+    ))]
     #[allow(clippy::result_unit_err)]
     pub fn to_file_path(&self) -> Result<PathBuf, ()> {
         if let Some(segments) = self.path_segments() {
@@ -2777,11 +2854,13 @@ impl<'de> serde::Deserialize<'de> for Url {
     }
 }
 
-#[cfg(any(unix, target_os = "redox", target_os = "wasi"))]
+#[cfg(all(feature = "std", any(unix, target_os = "redox", target_os = "wasi")))]
 fn path_to_file_url_segments(
     path: &Path,
     serialization: &mut String,
 ) -> Result<(u32, HostInternal), ()> {
+    use crate::parser::PATH_SEGMENT;
+    use percent_encoding::percent_encode;
     #[cfg(any(unix, target_os = "redox"))]
     use std::os::unix::prelude::OsStrExt;
     #[cfg(target_os = "wasi")]
@@ -2807,20 +2886,23 @@ fn path_to_file_url_segments(
     Ok((host_end, HostInternal::None))
 }
 
-#[cfg(windows)]
+#[cfg(all(feature = "std", windows))]
 fn path_to_file_url_segments(
     path: &Path,
     serialization: &mut String,
 ) -> Result<(u32, HostInternal), ()> {
     path_to_file_url_segments_windows(path, serialization)
 }
 
+#[cfg(feature = "std")]
 // Build this unconditionally to alleviate https://github.com/servo/rust-url/issues/102
 #[cfg_attr(not(windows), allow(dead_code))]
 fn path_to_file_url_segments_windows(
     path: &Path,
     serialization: &mut String,
 ) -> Result<(u32, HostInternal), ()> {
+    use crate::parser::PATH_SEGMENT;
+    use percent_encoding::percent_encode;
     use std::path::{Component, Prefix};
     if !path.is_absolute() {
         return Err(());
@@ -2879,11 +2961,12 @@ fn path_to_file_url_segments_windows(
     Ok((host_end, host_internal))
 }
 
-#[cfg(any(unix, target_os = "redox", target_os = "wasi"))]
+#[cfg(all(feature = "std", any(unix, target_os = "redox", target_os = "wasi")))]
 fn file_url_segments_to_pathbuf(
     host: Option<&str>,
     segments: str::Split<'_, char>,
 ) -> Result<PathBuf, ()> {
+    use percent_encoding::percent_decode;
     use std::ffi::OsStr;
     #[cfg(any(unix, target_os = "redox"))]
     use std::os::unix::prelude::OsStrExt;
@@ -2924,20 +3007,22 @@ fn file_url_segments_to_pathbuf(
     Ok(path)
 }
 
-#[cfg(windows)]
+#[cfg(all(feature = "std", windows))]
 fn file_url_segments_to_pathbuf(
     host: Option<&str>,
     segments: str::Split<char>,
 ) -> Result<PathBuf, ()> {
     file_url_segments_to_pathbuf_windows(host, segments)
 }
 
+#[cfg(feature = "std")]
 // Build this unconditionally to alleviate https://github.com/servo/rust-url/issues/102
 #[cfg_attr(not(windows), allow(dead_code))]
 fn file_url_segments_to_pathbuf_windows(
     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
     } else {

url/src/origin.rs

@@ -9,7 +9,8 @@
 use crate::host::Host;
 use crate::parser::default_port;
 use crate::Url;
-use std::sync::atomic::{AtomicUsize, Ordering};
+use alloc::{borrow::ToOwned, string::String};
+use core::sync::atomic::{AtomicUsize, Ordering};
 
 pub fn url_origin(url: &Url) -> Origin {
     let scheme = url.scheme();

url/src/parser.rs

@@ -6,9 +6,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::error::Error;
-use std::fmt::{self, Formatter, Write};
-use std::str;
+use alloc::string::{String, ToString};
+use core::fmt::{self, Formatter, Write};
+use core::str;
 
 use crate::host::{Host, HostInternal};
 use crate::Url;
@@ -72,7 +72,8 @@ macro_rules! simple_enum_error {
     }
 }
 
-impl Error for ParseError {}
+#[cfg(feature = "std")]
+impl std::error::Error for ParseError {}
 
 simple_enum_error! {
     EmptyHost => "empty host",
@@ -1107,7 +1108,7 @@ impl<'a> Parser<'a> {
         while let (Some(c), remaining) = input.split_first() {
             if let Some(digit) = c.to_digit(10) {
                 port = port * 10 + digit;
-                if port > ::std::u16::MAX as u32 {
+                if port > core::u16::MAX as u32 {
                     return Err(ParseError::InvalidPort);
                 }
                 has_any_digit = true;
@@ -1576,7 +1577,7 @@ pub fn ascii_alpha(ch: char) -> bool {
 
 #[inline]
 pub fn to_u32(i: usize) -> ParseResult<u32> {
-    if i <= ::std::u32::MAX as usize {
+    if i <= core::u32::MAX as usize {
         Ok(i as u32)
     } else {
         Err(ParseError::Overflow)