nits

Author: kornelski

examples/rewrite.rs

@@ -3,8 +3,8 @@
 use std::fs::File;
 use std::io::BufReader;
 use std::path::Path;
-use xml::reader::{ParserConfig, Result};
 use xml::EmitterConfig;
+use xml::reader::{ParserConfig, Result};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let arg = std::env::args_os().nth(1);

src/analyze.rs

@@ -5,8 +5,8 @@ use std::fs::File;
 use std::io::{self, BufReader, Read};
 use std::{cmp, env};
 
-use xml::reader::XmlEvent;
 use xml::ParserConfig;
+use xml::reader::XmlEvent;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut file;
@@ -67,7 +67,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             XmlEvent::EndElement { .. } => {
                 depth -= 1;
             },
-        };
+        }
     }
 
     namespaces.remove(xml::namespace::NS_EMPTY_URI);

src/namespace.rs

@@ -1,9 +1,9 @@
 //! Contains namespace manipulation types and functions.
 
 use std::borrow::Cow;
+use std::collections::HashSet;
 use std::collections::btree_map::Iter as Entries;
 use std::collections::btree_map::{BTreeMap, Entry};
-use std::collections::HashSet;
 use std::iter::{Map, Rev};
 use std::slice::Iter;
 

src/reader.rs

@@ -175,6 +175,7 @@ impl<'r> EventReader<&'r [u8]> {
     /// A convenience method to create an `XmlReader` from a string slice.
     #[inline]
     #[must_use]
+    #[allow(clippy::should_implement_trait)]
     pub fn from_str(source: &'r str) -> Self {
         EventReader::new(source.as_bytes())
     }

src/reader/error.rs

@@ -1,5 +1,5 @@
-use crate::reader::lexer::Token;
 use crate::Encoding;
+use crate::reader::lexer::Token;
 
 use std::borrow::Cow;
 use std::error::Error as _;

src/reader/parser.rs

@@ -398,6 +398,7 @@ impl PullParser {
     }
 
     #[cold]
+    #[allow(clippy::needless_pass_by_value)]
     fn error(&self, e: SyntaxError) -> Result {
         Err(Error {
             pos: self.lexer.position(),
@@ -465,17 +466,20 @@ impl PullParser {
     }
 
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     fn into_state(&mut self, st: State, ev: Option<Result>) -> Option<Result> {
         self.st = st;
         ev
     }
 
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     fn into_state_continue(&mut self, st: State) -> Option<Result> {
         self.into_state(st, None)
     }
 
     #[inline]
+    #[allow(clippy::wrong_self_convention)]
     fn into_state_emit(&mut self, st: State, ev: Result) -> Option<Result> {
         self.into_state(st, Some(ev))
     }

src/reader/parser/inside_comment.rs

@@ -9,7 +9,7 @@ impl PullParser {
         match t {
             Token::CommentEnd if self.config.c.ignore_comments => {
                 self.into_state_continue(State::OutsideTag)
-            }
+            },
 
             Token::CommentEnd => {
                 let data = self.take_buf();

src/util.rs

@@ -289,13 +289,13 @@ mod tests {
         match CharReader::new().next_char_from(&mut bytes).unwrap_err() {
             super::CharReadError::UnexpectedEof => {},
             e => panic!("Unexpected result: {e:?}")
-        };
+        }
 
         let mut bytes: &[u8] = b"\xff\x9f\x98\x32";     // invalid code point
         match CharReader::new().next_char_from(&mut bytes).unwrap_err() {
             super::CharReadError::Utf8(_) => {},
             e => panic!("Unexpected result: {e:?}")
-        };
+        }
 
         // error during read
         struct ErrorReader;

src/writer/emitter.rs

@@ -169,7 +169,7 @@ impl Emitter {
         self.indent_level += 1;
     }
 
-    fn before_end_element<W: Write>(&mut self, target: &mut W) -> Result<()> {
+    fn before_end_element<W: Write>(&self, target: &mut W) -> Result<()> {
         if self.config.perform_indent && self.indent_level > 0 && self.wrote_markup() &&
            !self.wrote_text() {
             let indent_level = self.indent_level;

tests/event_reader.rs

@@ -2,7 +2,7 @@
 
 use std::fmt;
 use std::fs::File;
-use std::io::{stderr, BufRead, BufReader, Write};
+use std::io::{BufRead, BufReader, Write, stderr};
 use std::path::Path;
 use xml::reader::ParserConfig2;
 
@@ -940,12 +940,11 @@ fn skip() {
                     assert_eq!(Ok(XmlEvent::EndElement{ name: OwnedName::local("a".to_string()) }), reader.next());
                     assert_eq!(Ok(XmlEvent::EndDocument), reader.next());
                     break 'outer;
-                } else {
-                    // Should never see the "c" element, since it should be skipped!
-                    assert_ne!(name.local_name, "c");
-                    // Should never see the "d" element, since it should be skipped!
-                    assert_ne!(name.local_name, "d");
                 }
+                // Should never see the "c" element, since it should be skipped!
+                assert_ne!(name.local_name, "c");
+                // Should never see the "d" element, since it should be skipped!
+                assert_ne!(name.local_name, "d");
             }
             XmlEvent::EndElement { name, .. } => {
                 // Should never see the "c" element, since it should be skipped!
@@ -966,7 +965,7 @@ fn skip() {
 
 struct Name<'a>(&'a OwnedName);
 
-impl<'a> fmt::Display for Name<'a> {
+impl fmt::Display for Name<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(ref namespace) = self.0.namespace {
             write!(f, "{{{namespace}}}")?;
@@ -982,7 +981,7 @@ impl<'a> fmt::Display for Name<'a> {
 
 struct Event<'a>(&'a Result<XmlEvent>);
 
-impl<'a> fmt::Display for Event<'a> {
+impl fmt::Display for Event<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let empty = String::new();
         match *self.0 {