Merge pull request #93 from shepmaster/warnings

shepmaster · web-flow · commit a8e9ca50a997 · 2025-06-09T15:53:18.000-04:00
Address clippy warnings
diff --git a/src/dom.rs b/src/dom.rs
@@ -19,7 +19,7 @@ macro_rules! wrapper(
         fn $name(self, node: *mut $inner) -> $wrapper<'d> {
             $wrapper {
                 document: self,
-                node: node,
+                node,
             }
         }
     )
diff --git a/src/lazy_hash_map.rs b/src/lazy_hash_map.rs
@@ -16,18 +16,18 @@ where
         LazyHashMap { map: None }
     }
 
-    pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
+    pub fn contains_key<Q>(&self, key: &Q) -> bool
     where
         K: Borrow<Q>,
-        Q: Hash + Eq,
+        Q: Hash + Eq + ?Sized,
     {
         self.map.as_ref().map_or(false, |m| m.contains_key(key))
     }
 
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>
+    pub fn get<Q>(&self, key: &Q) -> Option<&V>
     where
         K: Borrow<Q>,
-        Q: Hash + Eq,
+        Q: Hash + Eq + ?Sized,
     {
         self.map.as_ref().and_then(|m| m.get(key))
     }
diff --git a/src/lib.rs b/src/lib.rs
@@ -189,7 +189,7 @@ impl Package {
 
 impl PartialEq for Package {
     fn eq(&self, other: &Package) -> bool {
-        self as *const Package == other as *const Package
+        std::ptr::eq(self, other)
     }
 }
 
diff --git a/src/parser.rs b/src/parser.rs
@@ -19,8 +19,7 @@ use std::ascii::AsciiExt;
 use std::{
     char,
     collections::{BTreeSet, HashMap},
-    error, fmt, iter,
-    mem::replace,
+    error, fmt,
     ops::Deref,
 };
 
@@ -92,22 +91,22 @@ impl Recoverable for SpecificError {
     fn recoverable(&self) -> bool {
         use self::SpecificError::*;
 
-        match *self {
+        !matches!(
+            self,
             ExpectedEncoding
-            | ExpectedYesNo
-            | InvalidProcessingInstructionTarget
-            | MismatchedElementEndName
-            | InvalidDecimalReference
-            | InvalidHexReference
-            | UnknownNamedReference
-            | DuplicateAttribute
-            | RedefinedNamespace
-            | RedefinedDefaultNamespace
-            | EmptyNamespace
-            | UnknownNamespacePrefix
-            | UnclosedElement => false,
-            _ => true,
-        }
+                | ExpectedYesNo
+                | InvalidProcessingInstructionTarget
+                | MismatchedElementEndName
+                | InvalidDecimalReference
+                | InvalidHexReference
+                | UnknownNamedReference
+                | DuplicateAttribute
+                | RedefinedNamespace
+                | RedefinedDefaultNamespace
+                | EmptyNamespace
+                | UnknownNamespacePrefix
+                | UnclosedElement
+        )
     }
 }
 
@@ -359,7 +358,7 @@ enum Token<'a> {
     DocumentTypeDeclaration,
     Comment(&'a str),
     ProcessingInstruction(&'a str, Option<&'a str>),
-    Whitespace(&'a str),
+    Whitespace(#[allow(dead_code)] &'a str),
     ElementStart(Span<PrefixedName<'a>>),
     ElementStartClose,
     ElementSelfClose,
@@ -400,7 +399,7 @@ impl<'a> PullParser<'a> {
     }
 }
 
-fn parse_comment<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'_>> {
+fn parse_comment<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'a>> {
     let (xml, _) = try_parse!(xml
         .consume_literal("<!--")
         .map_err(|_| SpecificError::ExpectedComment));
@@ -569,7 +568,7 @@ fn parse_pi_value(xml: StringPoint<'_>) -> XmlProgress<'_, &str> {
     xml.consume_pi_value()
 }
 
-fn parse_pi<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'_>> {
+fn parse_pi<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'a>> {
     let (xml, _) = try_parse!(xml
         .consume_literal("<?")
         .map_err(|_| SpecificError::ExpectedProcessingInstruction));
@@ -727,11 +726,11 @@ fn parse_attribute_reference<'a>(
     success(Token::ReferenceAttributeValue(val), xml)
 }
 
-fn parse_char_data<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'_>> {
+fn parse_char_data<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'a>> {
     xml.consume_char_data().map(Token::CharData)
 }
 
-fn parse_cdata<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'_>> {
+fn parse_cdata<'a>(xml: StringPoint<'a>) -> XmlProgress<'a, Token<'a>> {
     let (xml, _) = try_parse!(xml.expect_literal("<![CDATA["));
     let (xml, text) = try_parse!(xml.consume_cdata());
     let (xml, _) = try_parse!(xml.expect_literal("]]>"));
@@ -922,7 +921,7 @@ impl<'d> DomBuilder<'d> {
 
     fn finish_opening_tag(&mut self) -> DomBuilderResult<()> {
         let deferred_element = self.element_names.last().expect("Unknown element name");
-        let attributes = DeferredAttributes::new(replace(&mut self.attributes, Vec::new()));
+        let attributes = DeferredAttributes::new(std::mem::take(&mut self.attributes));
 
         attributes.check_duplicates()?;
         let default_namespace = attributes.default_namespace()?;
@@ -971,7 +970,7 @@ impl<'d> DomBuilder<'d> {
         };
 
         for (prefix, ns_uri) in &new_prefix_mappings {
-            element.register_prefix(*prefix, ns_uri);
+            element.register_prefix(prefix, ns_uri);
         }
 
         if !self.seen_top_element {
@@ -1182,24 +1181,17 @@ where
     F: FnOnce(&str),
 {
     match ref_data {
+        #[allow(clippy::from_str_radix_10)]
         DecimalChar(span) => u32::from_str_radix(span.value, 10)
             .ok()
             .and_then(char::from_u32)
             .ok_or_else(|| span.map(|_| SpecificError::InvalidDecimalReference))
-            .and_then(|c| {
-                let s: String = iter::repeat(c).take(1).collect();
-                cb(&s);
-                Ok(())
-            }),
+            .map(|c| cb(&c.to_string())),
         HexChar(span) => u32::from_str_radix(span.value, 16)
             .ok()
             .and_then(char::from_u32)
             .ok_or_else(|| span.map(|_| SpecificError::InvalidHexReference))
-            .and_then(|c| {
-                let s: String = iter::repeat(c).take(1).collect();
-                cb(&s);
-                Ok(())
-            }),
+            .map(|c| cb(&c.to_string())),
         Entity(span) => {
             let s = match span.value {
                 "amp" => "&",
diff --git a/src/raw.rs b/src/raw.rs
@@ -109,10 +109,7 @@ pub enum ChildOfRoot {
 
 impl ChildOfRoot {
     fn is_element(&self) -> bool {
-        match *self {
-            ChildOfRoot::Element(_) => true,
-            _ => false,
-        }
+        matches!(self, ChildOfRoot::Element(_))
     }
 
     fn replace_parent(&self, parent: *mut Root) {
@@ -580,7 +577,7 @@ impl Connections {
     pub fn remove_attribute_from_parent(&self, child: *mut Attribute) {
         let child_r = unsafe { &mut *child };
         if let Some(parent) = child_r.parent {
-            self.remove_attribute_x(parent, |attr| attr as *mut Attribute == child);
+            self.remove_attribute_x(parent, |attr| std::ptr::eq(attr, child));
         }
     }
 
diff --git a/src/str.rs b/src/str.rs
@@ -5,7 +5,7 @@ trait StrParseExt {
         F2: Fn(char) -> bool;
 }
 
-impl<'a> StrParseExt for &'a str {
+impl StrParseExt for &str {
     fn end_of_start_rest<F1, F2>(&self, is_first: F1, is_rest: F2) -> Option<usize>
     where
         F1: Fn(char) -> bool,
@@ -55,7 +55,7 @@ pub trait XmlStr {
     fn end_of_int_subset(&self) -> Option<usize>;
 }
 
-impl<'a> XmlStr for &'a str {
+impl XmlStr for &str {
     fn end_of_attribute(&self, quote: &str) -> Option<usize> {
         if self.is_empty()
             || self.starts_with('&')
@@ -67,8 +67,7 @@ impl<'a> XmlStr for &'a str {
 
         let quote_char = quote.chars().next().expect("Cant have null quote");
 
-        self.find(&['&', '<', quote_char][..])
-            .or_else(|| Some(self.len()))
+        self.find(&['&', '<', quote_char][..]).or(Some(self.len()))
     }
 
     fn end_of_char_data(&self) -> Option<usize> {
@@ -131,7 +130,7 @@ impl<'a> XmlStr for &'a str {
         let mut positions = self.char_indices();
 
         match positions.next() {
-            Some((_, c)) if '<' == c => (),
+            Some((_, '<')) => (),
             _ => return None,
         };
 
@@ -157,6 +156,7 @@ impl<'a> XmlStr for &'a str {
 }
 
 /// Predicates used when parsing an characters in an XML document.
+#[allow(clippy::wrong_self_convention)]
 pub trait XmlChar {
     /// Is this a [NameStartChar](http://www.w3.org/TR/xml/#NT-NameStartChar)?
     fn is_name_start_char(self) -> bool;
@@ -184,8 +184,7 @@ impl XmlChar for char {
     }
 
     fn is_ncname_start_char(self) -> bool {
-        match self {
-            'A'..='Z'
+        matches!(self, 'A'..='Z'
             | '_'
             | 'a'..='z'
             | '\u{0000C0}'..='\u{0000D6}'
@@ -199,59 +198,39 @@ impl XmlChar for char {
             | '\u{003001}'..='\u{00D7FF}'
             | '\u{00F900}'..='\u{00FDCF}'
             | '\u{00FDF0}'..='\u{00FFFD}'
-            | '\u{010000}'..='\u{0EFFFF}' => true,
-            _ => false,
-        }
+            | '\u{010000}'..='\u{0EFFFF}')
     }
 
     fn is_ncname_char(self) -> bool {
         if self.is_ncname_start_char() {
             return true;
         }
-        match self {
-            '-'
+        matches!(self, '-'
             | '.'
             | '0'..='9'
             | '\u{00B7}'
             | '\u{0300}'..='\u{036F}'
-            | '\u{203F}'..='\u{2040}' => true,
-            _ => false,
-        }
+            | '\u{203F}'..='\u{2040}')
     }
 
     fn is_space_char(self) -> bool {
-        match self {
-            '\x20' | '\x09' | '\x0D' | '\x0A' => true,
-            _ => false,
-        }
+        matches!(self, '\x20' | '\x09' | '\x0D' | '\x0A')
     }
 
     fn is_decimal_char(self) -> bool {
-        match self {
-            '0'..='9' => true,
-            _ => false,
-        }
+        self.is_ascii_digit()
     }
 
     fn is_hex_char(self) -> bool {
-        match self {
-            '0'..='9' | 'a'..='f' | 'A'..='F' => true,
-            _ => false,
-        }
+        self.is_ascii_hexdigit()
     }
 
     fn is_encoding_start_char(self) -> bool {
-        match self {
-            'A'..='Z' | 'a'..='z' => true,
-            _ => false,
-        }
+        self.is_ascii_alphabetic()
     }
 
     fn is_encoding_rest_char(self) -> bool {
-        match self {
-            'A'..='Z' | 'a'..='z' | '0'..='9' | '.' | '_' | '-' => true,
-            _ => false,
-        }
+        matches!(self, 'A'..='Z' | 'a'..='z' | '0'..='9' | '.' | '_' | '-')
     }
 }
 
diff --git a/src/string_pool.rs b/src/string_pool.rs
@@ -142,13 +142,13 @@ impl StringPool {
     }
 
     pub fn intern<'s>(&'s self, s: &str) -> &'s str {
-        if s == "" {
+        if s.is_empty() {
             return "";
         }
 
         let mut index = self.index.borrow_mut();
         if let Some(interned) = index.get(s) {
-            return unsafe { mem::transmute(interned as &str) };
+            return unsafe { mem::transmute::<&str, &str>(interned) };
         }
 
         let interned_str = self.do_intern(s);
diff --git a/src/thindom.rs b/src/thindom.rs
@@ -317,7 +317,7 @@ macro_rules! node(
         impl<'d> $name<'d> {
             fn wrap(node: *mut $raw) -> $name<'d> {
                 $name {
-                    node: node,
+                    node,
                     lifetime: PhantomData,
                 }
             }
@@ -551,9 +551,9 @@ macro_rules! conversion_trait(
     ($res_type:ident, {
         $($leaf_type:ident => $variant:expr),*
     }) => (
-        $(impl<'d> Into<$res_type<'d>> for $leaf_type<'d> {
-            fn into(self) -> $res_type<'d> {
-                $variant(self)
+        $(impl<'d> From<$leaf_type<'d>> for $res_type<'d>{
+            fn from(other: $leaf_type<'d>) -> $res_type<'d> {
+                $variant(other)
             }
         })*
     )
@@ -576,9 +576,9 @@ conversion_trait!(
     }
 );
 
-impl<'d> Into<ChildOfElement<'d>> for ChildOfRoot<'d> {
-    fn into(self) -> ChildOfElement<'d> {
-        match self {
+impl<'d> From<ChildOfRoot<'d>> for ChildOfElement<'d> {
+    fn from(val: ChildOfRoot<'d>) -> Self {
+        match val {
             ChildOfRoot::Element(n) => ChildOfElement::Element(n),
             ChildOfRoot::Comment(n) => ChildOfElement::Comment(n),
             ChildOfRoot::ProcessingInstruction(n) => ChildOfElement::ProcessingInstruction(n),
diff --git a/src/writer.rs b/src/writer.rs

Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ macro_rules! wrapper(`
`19`	`19`	`fn $name(self, node: *mut $inner) -> $wrapper<'d> {`
`20`	`20`	`$wrapper {`
`21`	`21`	`document: self,`
`22`		`- node: node,`
	`22`	`+ node,`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`	`)`
Original file line number	Diff line number	Diff line change
`@@ -16,18 +16,18 @@ where`
`16`	`16`	`LazyHashMap { map: None }`
`17`	`17`	`}`
`18`	`18`
`19`		`- pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool`
	`19`	`+ pub fn contains_key<Q>(&self, key: &Q) -> bool`
`20`	`20`	`where`
`21`	`21`	`K: Borrow<Q>,`
`22`		`- Q: Hash + Eq,`
	`22`	`+ Q: Hash + Eq + ?Sized,`
`23`	`23`	`{`
`24`	`24`	`self.map.as_ref().map_or(false, \|m\| m.contains_key(key))`
`25`	`25`	`}`
`26`	`26`
`27`		`- pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>`
	`27`	`+ pub fn get<Q>(&self, key: &Q) -> Option<&V>`
`28`	`28`	`where`
`29`	`29`	`K: Borrow<Q>,`
`30`		`- Q: Hash + Eq,`
	`30`	`+ Q: Hash + Eq + ?Sized,`
`31`	`31`	`{`
`32`	`32`	`self.map.as_ref().and_then(\|m\| m.get(key))`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ impl Package {`
`189`	`189`
`190`	`190`	`impl PartialEq for Package {`
`191`	`191`	`fn eq(&self, other: &Package) -> bool {`
`192`		`- self as const Package == other as const Package`
	`192`	`+ std::ptr::eq(self, other)`
`193`	`193`	`}`
`194`	`194`	`}`
`195`	`195`
Original file line number	Diff line number	Diff line change
`@@ -109,10 +109,7 @@ pub enum ChildOfRoot {`
`109`	`109`
`110`	`110`	`impl ChildOfRoot {`
`111`	`111`	`fn is_element(&self) -> bool {`
`112`		`- match *self {`
`113`		`- ChildOfRoot::Element(_) => true,`
`114`		`- _ => false,`
`115`		`- }`
	`112`	`+ matches!(self, ChildOfRoot::Element(_))`
`116`	`113`	`}`
`117`	`114`
`118`	`115`	`fn replace_parent(&self, parent: *mut Root) {`
`@@ -580,7 +577,7 @@ impl Connections {`
`580`	`577`	`pub fn remove_attribute_from_parent(&self, child: *mut Attribute) {`
`581`	`578`	`let child_r = unsafe { &mut *child };`
`582`	`579`	`if let Some(parent) = child_r.parent {`
`583`		`- self.remove_attribute_x(parent, \|attr\| attr as *mut Attribute == child);`
	`580`	`+ self.remove_attribute_x(parent, \|attr\| std::ptr::eq(attr, child));`
`584`	`581`	`}`
`585`	`582`	`}`
`586`	`583`
Original file line number	Diff line number	Diff line change
`@@ -142,13 +142,13 @@ impl StringPool {`
`142`	`142`	`}`
`143`	`143`
`144`	`144`	`pub fn intern<'s>(&'s self, s: &str) -> &'s str {`
`145`		`- if s == "" {`
	`145`	`+ if s.is_empty() {`
`146`	`146`	`return "";`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`let mut index = self.index.borrow_mut();`
`150`	`150`	`if let Some(interned) = index.get(s) {`
`151`		`- return unsafe { mem::transmute(interned as &str) };`
	`151`	`+ return unsafe { mem::transmute::<&str, &str>(interned) };`
`152`	`152`	`}`
`153`	`153`
`154`	`154`	`let interned_str = self.do_intern(s);`