Somehow cannot be a base did not do what its documentation suggested.

Author: o0Ignition0o

src/lib.rs

@@ -687,7 +687,7 @@ impl Url {
     /// ```
     #[inline]
     pub fn cannot_be_a_base(&self) -> bool {
-        !self.slice(self.path_start..).starts_with('/')
+        !self.slice(self.scheme_end + 1..).starts_with('/')
     }
 
     /// Return the username for this URL (typically the empty string)

src/parser.rs

@@ -912,6 +912,14 @@ impl<'a> Parser<'a> {
         let (host, remaining) = Parser::parse_host(input, scheme_type)?;
         write!(&mut self.serialization, "{}", host).unwrap();
         let host_end = to_u32(self.serialization.len())?;
+        if remaining.starts_with(":") {
+            // Port with an empty host
+            if let Host::Domain(h) = &host {
+                if h.is_empty() {
+                    return Err(ParseError::EmptyHost);
+                }
+            }
+        }
         let (port, remaining) = if let Some(remaining) = remaining.split_prefix(':') {
             let scheme = || default_port(&self.serialization[..scheme_end as usize]);
             Parser::parse_port(remaining, scheme, self.context)?

src/quirks.rs

@@ -99,14 +99,13 @@ pub fn host(url: &Url) -> &str {
 
 /// Setter for https://url.spec.whatwg.org/#dom-url-host
 pub fn set_host(url: &mut Url, new_host: &str) -> Result<(), ()> {
+    // If context object’s url’s cannot-be-a-base-URL flag is set, then return.
+    if url.cannot_be_a_base() {
+        return Err(());
+    }
     let host;
     let opt_port;
     {
-        // If context object’s url’s cannot-be-a-base-URL flag is set, then return.
-        if url.cannot_be_a_base() {
-            return Err(());
-        }
-
         let scheme = url.scheme();
         let result = Parser::parse_host(Input::new(new_host), SchemeType::from(scheme));
         match result {
@@ -158,6 +157,20 @@ pub fn set_hostname(url: &mut Url, new_hostname: &str) -> Result<(), ()> {
     }
     let result = Parser::parse_host(Input::new(new_hostname), SchemeType::from(url.scheme()));
     if let Ok((host, _remaining)) = result {
+        if let Host::Domain(h) = &host {
+            if h.is_empty() {
+                // Empty host on special url
+                if SchemeType::from(url.scheme()).is_special()
+                    // Port with an empty host
+                    ||!port(&url).is_empty()
+                    // Empty host with includes credentials
+                    || !url.username().is_empty()
+                    || !url.password().unwrap_or(&"").is_empty()
+                {
+                    return Err(());
+                }
+            }
+        }
         url.set_host_internal(host, None);
         Ok(())
     } else {
@@ -202,18 +215,19 @@ pub fn pathname(url: &Url) -> &str {
 
 /// Setter for https://url.spec.whatwg.org/#dom-url-pathname
 pub fn set_pathname(url: &mut Url, new_pathname: &str) {
-    if !url.cannot_be_a_base() && !new_pathname.is_empty() {
-        if !SchemeType::from(url.scheme()).is_special()
+    if url.cannot_be_a_base() {
+        return;
+    }
+    if !SchemeType::from(url.scheme()).is_special()
             || Some('/') == new_pathname.chars().nth(0)
             // \\ is a segment delimiter for 'special' URLs"
             || Some('\\') == new_pathname.chars().nth(0)
-        {
-            url.set_path(new_pathname)
-        } else {
-            let mut path_to_set = String::from("/");
-            path_to_set.push_str(new_pathname);
-            url.set_path(&path_to_set)
-        }
+    {
+        url.set_path(new_pathname)
+    } else {
+        let mut path_to_set = String::from("/");
+        path_to_set.push_str(new_pathname);
+        url.set_path(&path_to_set)
     }
 }