Fix warnings and clippy lints

jan-auer · khuey · commit 48fb959a012f · 2020-05-06T07:37:13.000-07:00
diff --git a/build.rs b/build.rs
@@ -73,7 +73,7 @@ use std::io::Read;
         let entry = entry?;
 
         let path = entry.path();
-        let file_name = path.file_name().ok_or(io::Error::new(
+        let file_name = path.file_name().ok_or_else(|| io::Error::new(
             io::ErrorKind::Other,
             "no file name for AFL.rs seed test case",
         ))?;
diff --git a/examples/cppfilt.rs b/examples/cppfilt.rs
@@ -14,7 +14,6 @@ use std::process;
 
 /// Find the index of the first (potential) occurrence of a mangled C++ symbol
 /// in the given `haystack`.
-#[allow(needless_range_loop)]
 fn find_mangled(haystack: &[u8]) -> Option<usize> {
     if haystack.is_empty() {
         return None;
@@ -34,7 +33,7 @@ fn find_mangled(haystack: &[u8]) -> Option<usize> {
 
 /// Print the given `line` to `out`, with all mangled C++ symbols replaced with
 /// their demangled form.
-fn demangle_line<W>(out: &mut W, line: &[u8], options: &DemangleOptions) -> io::Result<()>
+fn demangle_line<W>(out: &mut W, line: &[u8], options: DemangleOptions) -> io::Result<()>
 where
     W: Write,
 {
@@ -44,7 +43,7 @@ where
         write!(out, "{}", String::from_utf8_lossy(&line[..idx]))?;
 
         if let Ok((sym, tail)) = BorrowedSymbol::with_tail(&line[idx..]) {
-            let demangled = sym.demangle(options).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+            let demangled = sym.demangle(&options).map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
             write!(out, "{}", demangled)?;
             line = tail;
         } else {
@@ -58,7 +57,7 @@ where
 
 /// Print all the lines from the given `input` to `out`, with all mangled C++
 /// symbols replaced with their demangled form.
-fn demangle_all<R, W>(input: &mut R, out: &mut W, options: &DemangleOptions) -> io::Result<()>
+fn demangle_all<R, W>(input: &mut R, out: &mut W, options: DemangleOptions) -> io::Result<()>
 where
     R: BufRead,
     W: Write,
@@ -110,9 +109,9 @@ fn main() {
             accumulated.push_str("\n");
             accumulated
         }));
-        demangle_all(&mut input, &mut stdout, &options)
+        demangle_all(&mut input, &mut stdout, options)
     } else {
-        demangle_all(&mut stdin, &mut stdout, &options)
+        demangle_all(&mut stdin, &mut stdout, options)
     };
 
     let code = match demangle_result {
diff --git a/src/ast.rs b/src/ast.rs
@@ -7,8 +7,6 @@ use std::cell::Cell;
 #[cfg(feature = "logging")]
 use std::cell::RefCell;
 use std::fmt::{self, Write};
-#[cfg(feature = "logging")]
-use std::error::Error;
 use std::hash::{Hash, Hasher};
 use std::mem;
 use std::ops;
@@ -27,10 +25,10 @@ thread_local! {
 
 impl AutoLogParse {
     #[cfg(feature = "logging")]
-    fn new<'a>(production: &'static str, input: IndexStr<'a>) -> AutoLogParse {
+    fn new(production: &'static str, input: IndexStr<'_>) -> AutoLogParse {
         LOG_DEPTH.with(|depth| {
             if *depth.borrow() == 0 {
-                println!("");
+                println!();
             }
 
             let indent: String = (0..*depth.borrow() * 4).map(|_| ' ').collect();
@@ -93,7 +91,7 @@ impl AutoLogDemangle {
     {
         LOG_DEPTH.with(|depth| {
             if *depth.borrow() == 0 {
-                println!("");
+                println!();
             }
 
             let indent: String = (0..*depth.borrow() * 4).map(|_| ' ').collect();
@@ -575,7 +573,7 @@ where
     pub fn new(
         subs: &'a SubstitutionTable,
         input: &'a [u8],
-        options: &DemangleOptions,
+        options: DemangleOptions,
         out: &'a mut W,
     ) -> DemangleContext<'a, W> {
         DemangleContext {
@@ -656,13 +654,12 @@ where
 
     #[inline]
     fn pop_inner_if(&mut self, inner: &'a dyn DemangleAsInner<'a, W>) -> bool {
-        if {
-            let last = match self.inner.last() {
-                None => return false,
-                Some(last) => *last,
-            };
-            ptr::eq(last, inner)
-        } {
+        let last = match self.inner.last() {
+            None => return false,
+            Some(last) => *last,
+        };
+
+        if ptr::eq(last, inner) {
             self.inner.pop();
             true
         } else {
@@ -890,7 +887,7 @@ macro_rules! reference_newtype {
         struct $newtype_name($oldtype);
 
         impl $newtype_name {
-            #[allow(ptr_arg)]
+            #[allow(clippy::ptr_arg)]
             #[allow(unsafe_code)]
             fn new(types: &$oldtype) -> &$newtype_name {
                 unsafe {
@@ -899,7 +896,7 @@ macro_rules! reference_newtype {
                     // requirements. An immutable reference does not allow
                     // dropping the referent, so no worries about double-free
                     // (additionally, see the assertion inside `Drop` below).
-                    mem::transmute(types)
+                    &*(types as *const $oldtype as *const $newtype_name)
                 }
             }
         }
@@ -997,7 +994,7 @@ where
         ctx.demangle_inner_prefixes(scope)?;
 
         if needs_paren {
-            write!(ctx, "{}", ')')?;
+            write!(ctx, ")")?;
         }
 
         write!(ctx, "(")?;
@@ -1424,7 +1421,7 @@ where
             Encoding::Function(ref name, ref fun_ty) => {
                 // Even if this function takes no args and doesn't have a return
                 // value (see below), it will have the void parameter.
-                debug_assert!(fun_ty.0.len() >= 1);
+                debug_assert!(!fun_ty.0.is_empty());
 
                 let scope = if let Some(leaf) = name.get_leaf_name(ctx.subs) {
                     match leaf {
@@ -1938,7 +1935,7 @@ impl Parse for NestedName {
                 NestedName::Template(cv_qualifiers, ref_qualifier, prefix),
                 tail,
             )),
-            _ => return Err(error::Error::UnexpectedText),
+            _ => Err(error::Error::UnexpectedText),
         }
     }
 }
@@ -2109,10 +2106,10 @@ impl Parse for PrefixHandle {
         try_begin_parse!("PrefixHandle", ctx, input);
 
         #[inline]
-        fn save<'a, 'b>(
-            subs: &'a mut SubstitutionTable,
+        fn save(
+            subs: &mut SubstitutionTable,
             prefix: Prefix,
-            tail_tail: IndexStr<'b>,
+            tail_tail: IndexStr<'_>,
         ) -> PrefixHandle {
             if let Some(b'E') = tail_tail.peek() {
                 // An `E` means that we just finished parsing a `<nested-name>`
@@ -3385,6 +3382,7 @@ impl CtorDtorName {
 ///        ::= <substitution>
 /// ```
 #[derive(Clone, Debug, PartialEq, Eq)]
+#[allow(clippy::large_enum_variant)]
 pub enum Type {
     /// A function type.
     Function(FunctionType),
@@ -5058,7 +5056,9 @@ where
             if need_comma {
                 write!(ctx, ", ")?;
             }
-            scope.as_mut().map(|scope| scope.in_arg = Some((arg_index, self)));
+            if let Some(ref mut scope) = scope {
+                scope.in_arg = Some((arg_index, self));
+            }
             self.0[arg_index].demangle(ctx, scope)?;
             need_comma = true;
         }
@@ -7628,7 +7628,7 @@ mod tests {
                         String::from_utf8_lossy(expected_tail)
                     );
                 }
-                if &subs[..] != &expected_subs[..] {
+                if subs[..] != expected_subs[..] {
                     panic!(
                         "Parsing {:?} as {} produced a substitutions table of\n\n\
                          {:#?}\n\n\
diff --git a/src/lib.rs b/src/lib.rs
@@ -33,7 +33,8 @@
 
 // Clippy stuff.
 #![allow(unknown_lints)]
-#![allow(inline_always)]
+#![allow(clippy::inline_always)]
+#![allow(clippy::redundant_field_names)]
 
 #![cfg_attr(all(not(feature = "std"), feature = "alloc"), no_std)]
 #![cfg_attr(all(not(feature = "std"), feature = "alloc"), feature(alloc))]
@@ -153,7 +154,7 @@ where
             if tail.is_empty() {
                 parsed
             } else {
-                return Err(Error::UnexpectedText.into());
+                return Err(Error::UnexpectedText);
             }
         };
 
@@ -196,13 +197,14 @@ substitutions = {:#?}",
     /// let demangled_again = sym.demangle(&options).unwrap();
     /// assert_eq!(demangled_again, demangled);
     /// ```
+    #[allow(clippy::trivially_copy_pass_by_ref)]
     pub fn demangle(&self, options: &DemangleOptions) -> ::std::result::Result<String, fmt::Error> {
         let mut out = String::new();
         {
             let mut ctx = ast::DemangleContext::new(
                 &self.substitutions,
                 self.raw.as_ref(),
-                options,
+                *options,
                 &mut out,
             );
             self.parsed.demangle(&mut ctx, None)?;
@@ -213,11 +215,12 @@ substitutions = {:#?}",
 
     /// Demangle the symbol to a DemangleWrite, which lets the consumer be informed about
     /// syntactic structure.
+    #[allow(clippy::trivially_copy_pass_by_ref)]
     pub fn structured_demangle<W: DemangleWrite>(&self, out: &mut W, options: &DemangleOptions) -> fmt::Result {
         let mut ctx = ast::DemangleContext::new(
             &self.substitutions,
             self.raw.as_ref(),
-            options,
+            *options,
             out,
         );
         self.parsed.demangle(&mut ctx, None)
@@ -307,7 +310,7 @@ impl<'a, T> Symbol<&'a T>
 AST = {:#?}
 
 substitutions = {:#?}",
-            String::from_utf8_lossy(symbol.raw.as_ref()),
+            String::from_utf8_lossy(symbol.raw),
             symbol.parsed,
             symbol.substitutions
         );
@@ -327,7 +330,7 @@ where
             let mut ctx = ast::DemangleContext::new(
                 &self.substitutions,
                 self.raw.as_ref(),
-                &options,
+                options,
                 &mut out,
             );
             self.parsed.demangle(&mut ctx, None).map_err(|err| {
diff --git a/src/subs.rs b/src/subs.rs
@@ -11,6 +11,7 @@ use vec::Vec;
 /// table.
 #[doc(hidden)]
 #[derive(Clone, Debug, PartialEq, Eq)]
+#[allow(clippy::large_enum_variant)]
 pub enum Substitutable {
     /// An `<unscoped-template-name>` production.
     UnscopedTemplateName(ast::UnscopedTemplateName),
diff --git a/tests/libxul.rs b/tests/libxul.rs
@@ -5,11 +5,11 @@ use std::fs;
 use std::io::{BufRead, BufReader, BufWriter, Write};
 use std::process;
 
-const NUMBER_OF_LIBXUL_SYMBOLS: usize = 274346;
+const NUMBER_OF_LIBXUL_SYMBOLS: usize = 274_346;
 
 // These counts should only go up!
-const NUMBER_OF_LIBXUL_SYMBOLS_THAT_PARSE: usize = 274346;
-const NUMBER_OF_LIBXUL_SYMBOLS_THAT_DEMANGLE: usize = 274346;
+const NUMBER_OF_LIBXUL_SYMBOLS_THAT_PARSE: usize = 274_346;
+const NUMBER_OF_LIBXUL_SYMBOLS_THAT_DEMANGLE: usize = 274_346;
 
 fn get_cppfilt() -> &'static str {
     if cfg!(not(target_os = "macos")) {
@@ -87,7 +87,7 @@ fn libxul_symbols_demangle() {
 
             // Demangle the symbol.
             demangled.clear();
-            if let Ok(_) = write!(&mut demangled, "{}", sym) {
+            if write!(&mut demangled, "{}", sym).is_ok() {
                 num_demangled += 1;
 
                 // Finally, we are going to have `c++filt` demangle the
@@ -96,7 +96,7 @@ fn libxul_symbols_demangle() {
                     .write_all(&line)
                     .expect("should write line contents into c++filt");
                 cppfilt_stdin
-                    .write(b"\n")
+                    .write_all(b"\n")
                     .expect("should write newline into c++filt");
                 cppfilt_stdin.flush().expect("should flush c++filt stdin");
 
diff --git a/tests/tests.rs b/tests/tests.rs
@@ -20,7 +20,7 @@ fn assert_demangles_as(mangled: &str, expected: &str, options: Option<DemangleOp
     };
 
     if expected != actual {
-        println!("");
+        println!();
         println!("Diff:");
         println!("--- expected");
         print!("+++ actual");
@@ -43,7 +43,7 @@ fn assert_demangles_as(mangled: &str, expected: &str, options: Option<DemangleOp
             }
             last = Some(cmp);
         }
-        println!("");
+        println!();
     }
 
     assert_eq!(expected, actual);

Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ fn assert_demangles_as(mangled: &str, expected: &str, options: Option<DemangleOp`
`20`	`20`	`};`
`21`	`21`
`22`	`22`	`if expected != actual {`
`23`		`- println!("");`
	`23`	`+ println!();`
`24`	`24`	`println!("Diff:");`
`25`	`25`	`println!("--- expected");`
`26`	`26`	`print!("+++ actual");`
`@@ -43,7 +43,7 @@ fn assert_demangles_as(mangled: &str, expected: &str, options: Option<DemangleOp`
`43`	`43`	`}`
`44`	`44`	`last = Some(cmp);`
`45`	`45`	`}`
`46`		`- println!("");`
	`46`	`+ println!();`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`assert_eq!(expected, actual);`