url: clean up clippy warnings

url/src/lib.rs

@@ -1663,10 +1663,8 @@ impl Url {
             let scheme_type = SchemeType::from(self.scheme());
             if scheme_type.is_special() {
                 return Err(ParseError::EmptyHost);
-            } else {
-                if self.serialization.len() == self.path_start as usize {
-                    self.serialization.push('/');
-                }
+            } else if self.serialization.len() == self.path_start as usize {
+                self.serialization.push('/');
             }
             debug_assert!(self.byte_at(self.scheme_end) == b':');
             debug_assert!(self.byte_at(self.path_start) == b'/');
@@ -2583,12 +2581,11 @@ fn file_url_segments_to_pathbuf(
         bytes.extend(percent_decode(segment.as_bytes()));
     }
     // A windows drive letter must end with a slash.
-    if bytes.len() > 2 {
-        if matches!(bytes[bytes.len() - 2], b'a'..=b'z' | b'A'..=b'Z')
-            && matches!(bytes[bytes.len() - 1], b':' | b'|')
-        {
-            bytes.push(b'/');
-        }
+    if bytes.len() > 2
+        && matches!(bytes[bytes.len() - 2], b'a'..=b'z' | b'A'..=b'Z')
+        && matches!(bytes[bytes.len() - 1], b':' | b'|')
+    {
+        bytes.push(b'/');
     }
     let os_str = OsStr::from_bytes(&bytes);
     let path = PathBuf::from(os_str);

url/src/parser.rs

@@ -52,6 +52,7 @@ macro_rules! simple_enum_error {
         ///
         /// This may be extended in the future so exhaustive matching is
         /// discouraged with an unused variant.
+        #[allow(clippy::manual_non_exhaustive)] // introduced in 1.40, MSRV is 1.36
         #[derive(PartialEq, Eq, Clone, Copy, Debug)]
         pub enum ParseError {
             $(
@@ -547,15 +548,15 @@ impl<'a> Parser<'a> {
                     self.parse_query_and_fragment(scheme_type, scheme_end, remaining)?;
                 return Ok(Url {
                     serialization: self.serialization,
-                    scheme_end: scheme_end,
+                    scheme_end,
                     username_end: host_start,
-                    host_start: host_start,
-                    host_end: host_end,
-                    host: host,
+                    host_start,
+                    host_end,
+                    host,
                     port: None,
                     path_start: host_end,
-                    query_start: query_start,
-                    fragment_start: fragment_start,
+                    query_start,
+                    fragment_start,
                 });
             } else {
                 self.serialization.push_str("file://");
@@ -598,15 +599,15 @@ impl<'a> Parser<'a> {
                 let host_end = host_end as u32;
                 return Ok(Url {
                     serialization: self.serialization,
-                    scheme_end: scheme_end,
+                    scheme_end,
                     username_end: host_start,
                     host_start,
                     host_end,
                     host,
                     port: None,
                     path_start: host_end,
-                    query_start: query_start,
-                    fragment_start: fragment_start,
+                    query_start,
+                    fragment_start,
                 });
             }
         }
@@ -678,15 +679,15 @@ impl<'a> Parser<'a> {
                         let path_start = path_start as u32;
                         Ok(Url {
                             serialization: self.serialization,
-                            scheme_end: scheme_end,
+                            scheme_end,
                             username_end: path_start,
                             host_start: path_start,
                             host_end: path_start,
                             host: HostInternal::None,
                             port: None,
-                            path_start: path_start,
-                            query_start: query_start,
-                            fragment_start: fragment_start,
+                            path_start,
+                            query_start,
+                            fragment_start,
                         })
                     }
                 }
@@ -701,15 +702,15 @@ impl<'a> Parser<'a> {
             let path_start = path_start as u32;
             Ok(Url {
                 serialization: self.serialization,
-                scheme_end: scheme_end,
+                scheme_end,
                 username_end: path_start,
                 host_start: path_start,
                 host_end: path_start,
                 host: HostInternal::None,
                 port: None,
-                path_start: path_start,
-                query_start: query_start,
-                fragment_start: fragment_start,
+                path_start,
+                query_start,
+                fragment_start,
             })
         }
     }
@@ -804,10 +805,10 @@ impl<'a> Parser<'a> {
                 self.pop_path(scheme_type, base_url.path_start as usize);
                 // A special url always has a path.
                 // A path always starts with '/'
-                if self.serialization.len() == base_url.path_start as usize {
-                    if SchemeType::from(base_url.scheme()).is_special() || !input.is_empty() {
-                        self.serialization.push('/');
-                    }
+                if self.serialization.len() == base_url.path_start as usize
+                    && (SchemeType::from(base_url.scheme()).is_special() || !input.is_empty())
+                {
+                    self.serialization.push('/');
                 }
                 let remaining = match input.split_first() {
                     (Some('/'), remaining) => self.parse_path(