Apply all clippy suggestions

nbdd0121 · jwnrt · commit ea0720ccf984 · 2023-10-27T12:24:53.000+01:00
Signed-off-by: Gary Guo &lt;gary.guo@lowrisc.org&gt;
diff --git a/annotate_derive/src/ast.rs b/annotate_derive/src/ast.rs
@@ -59,9 +59,9 @@ impl<'a> Struct<'a> {
         let fields = Field::multiple_from_syn(&data.fields, span)?;
         Ok(Struct {
             original: node,
-            attrs: attrs,
+            attrs,
             ident: node.ident.clone(),
-            fields: fields,
+            fields,
         })
     }
 }
@@ -80,9 +80,9 @@ impl<'a> Enum<'a> {
             .collect::<Result<_>>()?;
         Ok(Enum {
             original: node,
-            attrs: attrs,
+            attrs,
             ident: node.ident.clone(),
-            variants: variants,
+            variants,
         })
     }
 }
@@ -116,7 +116,7 @@ impl<'a> Variant<'a> {
         let attrs = attr::get(&node.attrs)?;
         Ok(Variant {
             original: node,
-            attrs: attrs,
+            attrs,
             ident: node.ident.clone(),
             fields: Field::multiple_from_syn(&node.fields, span)?,
         })
diff --git a/examples/autoschema.rs b/examples/autoschema.rs
@@ -62,7 +62,7 @@ impl Schema {
     }
 
     fn check_str(&mut self, s: &str) {
-        if let Ok(_) = Int::from_str_radix(s, 0) {
+        if Int::from_str_radix(s, 0).is_ok() {
             self.integer += 1;
         } else {
             match s {
diff --git a/src/integer.rs b/src/integer.rs
@@ -184,16 +184,16 @@ impl Int {
         self.value.format(*base.unwrap_or(&Base::Dec), self.width)
     }
 
-    fn strip_numeric_prefix<'a>(src: &'a str, ch: u8) -> &'a str {
+    fn strip_numeric_prefix(src: &str, ch: u8) -> &str {
         let lo = ['0', (ch | 0x20) as char];
         let up = ['0', (ch & !0x20) as char];
-        if src.starts_with(&lo) || src.starts_with(&up) {
+        if src.starts_with(lo) || src.starts_with(up) {
             &src[2..]
         } else {
             src
         }
     }
-    fn detect_numeric_prefix<'a>(src: &'a str) -> (Base, &'a str) {
+    fn detect_numeric_prefix(src: &str) -> (Base, &str) {
         let bytes = src.as_bytes();
         if src.len() >= 2 && bytes[0] == b'0' {
             match bytes[1] {
diff --git a/src/json.rs b/src/json.rs
@@ -677,14 +677,7 @@ const SPACE: &str = "
 
 // More strict than javascript.
 fn bad_identifier_char(ch: char) -> bool {
-    match ch {
-        '0'..='9' => false,
-        'A'..='Z' => false,
-        'a'..='z' => false,
-        '_' => false,
-        '$' => false,
-        _ => true,
-    }
+    !matches!(ch, '0'..='9' | 'A'..='Z' | 'a'..='z' | '_' | '$')
 }
 
 fn is_reserved_word(word: &str) -> bool {
@@ -743,11 +736,11 @@ fn is_reserved_word(word: &str) -> bool {
 }
 
 fn is_legal_bareword(word: &str) -> bool {
-    if word.len() == 0 {
+    if word.is_empty() {
         return false;
     }
-    let ch = word.chars().nth(0).unwrap();
-    !((ch >= '0' && ch <= '9') || word.contains(bad_identifier_char) || is_reserved_word(word))
+    let ch = word.chars().next().unwrap();
+    !(ch.is_ascii_digit() || word.contains(bad_identifier_char) || is_reserved_word(word))
 }
 
 #[cfg(test)]
diff --git a/src/relax.rs b/src/relax.rs
@@ -70,8 +70,7 @@ impl Default for Relax {
 impl Relax {
     /// Creates a strict json parser.
     pub fn json() -> Self {
-        Relax {
-            inner: Default::default(),
+        Self {
             comma_trailing: false,
             comma_optional: false,
             number_bin: false,
@@ -87,31 +86,34 @@ impl Relax {
             comment_slash: false,
             comment_hash: false,
             comment_block: false,
+            ..Self::default()
         }
     }
 
     /// Creates a json5 parser.
     pub fn json5() -> Self {
-        let mut r = Self::default();
-        r.comma_optional = false;
-        r.string_unquoted = false;
-        r.string_hjson_multiline = false;
-        r.comment_hash = false;
-        r.number_bin = false;
-        r.number_oct = false;
-        r
+        Self {
+            comma_optional: false,
+            string_unquoted: false,
+            string_hjson_multiline: false,
+            comment_hash: false,
+            number_bin: false,
+            number_oct: false,
+            ..Self::default()
+        }
     }
 
     /// Creates a hjson parser.
     pub fn hjson() -> Self {
-        let mut r = Self::default();
-        r.string_json5_multiline = false;
-        r.number_bin = false;
-        r.number_hex = false;
-        r.number_oct = false;
-        r.number_plus = false;
-        r.number_lax_dec_point = false;
-        r
+        Self {
+            string_json5_multiline: false,
+            number_bin: false,
+            number_hex: false,
+            number_oct: false,
+            number_plus: false,
+            number_lax_dec_point: false,
+            ..Self::default()
+        }
     }
 
     /// Parses a string into a `Document`.
@@ -217,7 +219,7 @@ impl Relax {
                 "hexadecimal literal",
                 pair.as_span().start_pos(),
             )?;
-            return Self::from_str_radix(text, 16);
+            Self::from_str_radix(text, 16)
         } else if t.starts_with("0b") || t.starts_with("0B") {
             // Binary integer.
             Self::syntax_error(
@@ -389,10 +391,10 @@ impl Relax {
                 pair.as_span().start_pos(),
             )?;
             let c = c.strip_suffix("*/").unwrap().trim_end();
-            let lines = c.split("\n").map(str::trim).collect::<Vec<_>>();
+            let lines = c.split('\n').map(str::trim).collect::<Vec<_>>();
             let lines = Self::strip_leading_prefix(&lines, '*');
             let lines = Self::strip_leading_prefix(&lines, ' ');
-            let start = if lines.get(0).map(|s| s.is_empty()) == Some(true) {
+            let start = if lines.first().map(|s| s.is_empty()) == Some(true) {
                 1
             } else {
                 0
@@ -405,7 +407,7 @@ impl Relax {
                 "slash comment",
                 pair.as_span().start_pos(),
             )?;
-            let lines = comment.split("\n").map(str::trim).collect::<Vec<_>>();
+            let lines = comment.split('\n').map(str::trim).collect::<Vec<_>>();
             let lines = Self::strip_leading_prefix(&lines, '/');
             let lines = Self::strip_leading_prefix(&lines, ' ');
             let end = lines.len()
@@ -416,13 +418,13 @@ impl Relax {
                 };
             let c = lines[..end].join("\n");
             Ok(Document::Comment(c, CommentFormat::SlashSlash))
-        } else if comment.starts_with("#") {
+        } else if comment.starts_with('#') {
             Self::syntax_error(
                 !self.comment_hash,
                 "hash comment",
                 pair.as_span().start_pos(),
             )?;
-            let lines = comment.split("\n").map(str::trim).collect::<Vec<_>>();
+            let lines = comment.split('\n').map(str::trim).collect::<Vec<_>>();
             let lines = Self::strip_leading_prefix(&lines, '#');
             let lines = Self::strip_leading_prefix(&lines, ' ');
             let end = lines.len()
@@ -463,7 +465,7 @@ impl Relax {
             Ok(Document::String(value.join("\n"), StrFormat::Multiline))
         } else if s.starts_with('\'') || s.starts_with('"') {
             Self::syntax_error(
-                !self.string_single_quote && s.starts_with("'"),
+                !self.string_single_quote && s.starts_with('\''),
                 "single quote",
                 pair.as_span().start_pos(),
             )?;
@@ -595,7 +597,7 @@ impl Relax {
                 }
             }
 
-            _ => Err(Error::Unknown(format!("{:?}", pair)).into()),
+            _ => Err(Error::Unknown(format!("{:?}", pair))),
         }
     }
 }
@@ -723,7 +725,7 @@ mod tests {
         }
     }
 
-    fn kv_extract<'a>(kv: Option<&'a Document>) -> Result<(&'a str, &'a str)> {
+    fn kv_extract(kv: Option<&Document>) -> Result<(&str, &str)> {
         if let Some((Document::String(k, _), Document::String(v, _))) =
             kv.map(Document::as_kv).transpose()?
         {
diff --git a/src/ser.rs b/src/ser.rs
@@ -60,7 +60,7 @@ impl<'a> AnnotatedSerializer<'a> {
     }
 
     fn annotate(&self, variant: Option<&str>, field: &MemberId) -> Option<Self> {
-        match self.annotator.map(|a| a.format(variant, field)).flatten() {
+        match self.annotator.and_then(|a| a.format(variant, field)) {
             Some(Format::Block) => Some(self.with_strformat(StrFormat::Multiline)),
             Some(Format::Binary) => Some(self.with_base(Base::Bin)),
             Some(Format::Decimal) => Some(self.with_base(Base::Dec)),
@@ -76,8 +76,7 @@ impl<'a> AnnotatedSerializer<'a> {
 
     fn comment(&self, variant: Option<&str>, field: &MemberId) -> Option<Document> {
         self.annotator
-            .map(|a| a.comment(variant, field))
-            .flatten()
+            .and_then(|a| a.comment(variant, field))
             .map(|c| Document::Comment(c, CommentFormat::Standard))
     }
 
@@ -152,7 +151,7 @@ impl<'s, 'a> ser::Serializer for &'s mut AnnotatedSerializer<'a> {
     }
 
     fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
-        Ok(Document::Float(v as f64))
+        Ok(Document::Float(v))
     }
 
     fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
diff --git a/src/yaml.rs b/src/yaml.rs
@@ -189,12 +189,7 @@ impl YamlEmitter {
                 if let Document::Fragment(frags) = value {
                     let mut val_done = false;
                     let mut it = frags.iter().peekable();
-                    loop {
-                        let node = if let Some(n) = it.next() {
-                            n
-                        } else {
-                            break;
-                        };
+                    while let Some(node) = it.next() {
                         let next = it.peek();
                         if let Some((c, f)) = node.comment() {
                             if val_done {
@@ -239,12 +234,7 @@ impl YamlEmitter {
             let mut key_done = false;
             let mut val_done = false;
             let mut it = nodes.iter().peekable();
-            loop {
-                let node = if let Some(n) = it.next() {
-                    n
-                } else {
-                    break;
-                };
+            while let Some(node) = it.next() {
                 let next = it.peek();
                 if let Some((c, f)) = node.comment() {
                     if val_done {
@@ -515,13 +505,16 @@ fn need_quotes(string: &str) -> bool {
         string.starts_with(' ') || string.ends_with(' ')
     }
 
-    string == ""
+    string.is_empty()
         || need_quotes_spaces(string)
-        || string.starts_with(|character: char| match character {
-            '&' | '*' | '?' | '|' | '-' | '<' | '>' | '=' | '!' | '%' | '@' => true,
-            _ => false,
+        || string.starts_with(|character: char| {
+            matches!(
+                character,
+                '&' | '*' | '?' | '|' | '-' | '<' | '>' | '=' | '!' | '%' | '@'
+            )
         })
-        || string.contains(|character: char| match character {
+        || string.contains(|character: char| {
+            matches!(character,
             ':'
             | '{'
             | '}'
@@ -538,8 +531,7 @@ fn need_quotes(string: &str) -> bool {
             | '\n'
             | '\r'
             | '\x0e'..='\x1a'
-            | '\x1c'..='\x1f' => true,
-            _ => false,
+            | '\x1c'..='\x1f')
         })
         || [
             // http://yaml.org/type/bool.html
diff --git a/tests/test_erased.rs b/tests/test_erased.rs
@@ -10,10 +10,9 @@ struct Hello {
 }
 
 fn hello() -> Box<dyn Annotate> {
-    let hello = Box::new(Hello {
+    Box::new(Hello {
         message: "Hello World!".into(),
-    });
-    hello
+    })
 }
 
 #[test]

Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ impl Schema {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`fn check_str(&mut self, s: &str) {`
`65`		`- if let Ok(_) = Int::from_str_radix(s, 0) {`
	`65`	`+ if Int::from_str_radix(s, 0).is_ok() {`
`66`	`66`	`self.integer += 1;`
`67`	`67`	`} else {`
`68`	`68`	`match s {`
Original file line number	Diff line number	Diff line change
`@@ -184,16 +184,16 @@ impl Int {`
`184`	`184`	`self.value.format(*base.unwrap_or(&Base::Dec), self.width)`
`185`	`185`	`}`
`186`	`186`
`187`		`- fn strip_numeric_prefix<'a>(src: &'a str, ch: u8) -> &'a str {`
	`187`	`+ fn strip_numeric_prefix(src: &str, ch: u8) -> &str {`
`188`	`188`	`let lo = ['0', (ch \| 0x20) as char];`
`189`	`189`	`let up = ['0', (ch & !0x20) as char];`
`190`		`- if src.starts_with(&lo) \|\| src.starts_with(&up) {`
	`190`	`+ if src.starts_with(lo) \|\| src.starts_with(up) {`
`191`	`191`	`&src[2..]`
`192`	`192`	`} else {`
`193`	`193`	`src`
`194`	`194`	`}`
`195`	`195`	`}`
`196`		`- fn detect_numeric_prefix<'a>(src: &'a str) -> (Base, &'a str) {`
	`196`	`+ fn detect_numeric_prefix(src: &str) -> (Base, &str) {`
`197`	`197`	`let bytes = src.as_bytes();`
`198`	`198`	`if src.len() >= 2 && bytes[0] == b'0' {`
`199`	`199`	`match bytes[1] {`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ impl<'a> AnnotatedSerializer<'a> {`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`fn annotate(&self, variant: Option<&str>, field: &MemberId) -> Option<Self> {`
`63`		`- match self.annotator.map(\|a\| a.format(variant, field)).flatten() {`
	`63`	`+ match self.annotator.and_then(\|a\| a.format(variant, field)) {`
`64`	`64`	`Some(Format::Block) => Some(self.with_strformat(StrFormat::Multiline)),`
`65`	`65`	`Some(Format::Binary) => Some(self.with_base(Base::Bin)),`
`66`	`66`	`Some(Format::Decimal) => Some(self.with_base(Base::Dec)),`
`@@ -76,8 +76,7 @@ impl<'a> AnnotatedSerializer<'a> {`
`76`	`76`
`77`	`77`	`fn comment(&self, variant: Option<&str>, field: &MemberId) -> Option<Document> {`
`78`	`78`	`self.annotator`
`79`		`- .map(\|a\| a.comment(variant, field))`
`80`		`- .flatten()`
	`79`	`+ .and_then(\|a\| a.comment(variant, field))`
`81`	`80`	`.map(\|c\| Document::Comment(c, CommentFormat::Standard))`
`82`	`81`	`}`
`83`	`82`
`@@ -152,7 +151,7 @@ impl<'s, 'a> ser::Serializer for &'s mut AnnotatedSerializer<'a> {`
`152`	`151`	`}`
`153`	`152`
`154`	`153`	`fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {`
`155`		`- Ok(Document::Float(v as f64))`
	`154`	`+ Ok(Document::Float(v))`
`156`	`155`	`}`
`157`	`156`
`158`	`157`	`fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {`
Original file line number	Diff line number	Diff line change
`@@ -10,10 +10,9 @@ struct Hello {`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`fn hello() -> Box<dyn Annotate> {`
`13`		`- let hello = Box::new(Hello {`
	`13`	`+ Box::new(Hello {`
`14`	`14`	`message: "Hello World!".into(),`
`15`		`- });`
`16`		`- hello`
	`15`	`+ })`
`17`	`16`	`}`
`18`	`17`
`19`	`18`	`#[test]`