more clippy fixes

marcograss · marcograss · commit fa9132cd1c3a · 2024-05-23T14:52:58.000+08:00
diff --git a/src/elf.rs b/src/elf.rs
@@ -631,21 +631,16 @@ impl LibraryLookup {
         runpath: &VecRpath,
         libfilename: &str,
     ) -> Option<PathBuf> {
-        let parentbinpath = if let Some(parent) = binarypath.parent() {
-            parent.to_str()
-        } else {
-            None
-        };
+        let parentbinpath =
+            binarypath.parent().and_then(|parent| parent.to_str());
 
         for rpath in rpath.iter().filter_map(|rpath| match rpath {
             Rpath::YesRW(ref str) | Rpath::Yes(ref str) => Some(str),
             Rpath::None => None,
         }) {
-            let rpath = if let Some(p) = parentbinpath {
+            let rpath = parentbinpath.map_or(Either::Right(rpath), |p| {
                 Either::Left(rpath.replace("$ORIGIN", p))
-            } else {
-                Either::Right(rpath)
-            };
+            });
             let path = Path::new(&rpath).join(libfilename);
             if path.is_file() {
                 return Some(path);
@@ -661,11 +656,9 @@ impl LibraryLookup {
 
             Rpath::None => None,
         }) {
-            let runpath = if let Some(p) = parentbinpath {
+            let runpath = parentbinpath.map_or(Either::Right(runpath), |p| {
                 Either::Left(runpath.replace("$ORIGIN", p))
-            } else {
-                Either::Right(runpath)
-            };
+            });
             let path = Path::new(&runpath).join(libfilename);
             if path.is_file() {
                 return Some(path);
diff --git a/src/ldso.rs b/src/ldso.rs
@@ -53,7 +53,7 @@ impl fmt::Display for LdSoError {
 
 impl From<io::Error> for LdSoError {
     fn from(e: io::Error) -> Self {
-        LdSoError::IO(e)
+        Self::IO(e)
     }
 }
 
@@ -88,12 +88,10 @@ impl LdSoLookup {
                     let file = file.map_err(|e| {
                         LdSoError::Glob(e, PathBuf::from(include_path))
                     })?;
-                    lookup_paths.append(
-                        &mut LdSoLookup::parse_ldso_conf_file(
-                            &file,
-                            include_depth + 1,
-                        )?,
-                    );
+                    lookup_paths.append(&mut Self::parse_ldso_conf_file(
+                        &file,
+                        include_depth + 1,
+                    )?);
                 }
                 continue;
             }
@@ -119,9 +117,9 @@ impl LdSoLookup {
     /// # Errors
     /// Will fail if the ld.so.conf configuration can not be read or has an
     /// invalid format.
-    pub fn gen_lookup_dirs() -> Result<LdSoLookup, LdSoError> {
-        Ok(LdSoLookup {
-            lookup_dirs: LdSoLookup::parse_ldso_conf_file(
+    pub fn gen_lookup_dirs() -> Result<Self, LdSoError> {
+        Ok(Self {
+            lookup_dirs: Self::parse_ldso_conf_file(
                 Path::new("/etc/ld.so.conf"),
                 0,
             )?,
diff --git a/src/main.rs b/src/main.rs
@@ -301,8 +301,8 @@ impl From<std::io::Error> for ParseError {
 
 #[cfg(all(target_os = "linux", feature = "elf"))]
 impl From<LdSoError> for ParseError {
-    fn from(err: LdSoError) -> ParseError {
-        ParseError::LdSo(err)
+    fn from(err: LdSoError) -> Self {
+        Self::LdSo(err)
     }
 }
 
@@ -533,18 +533,16 @@ fn parse_dependencies(
     while !to_scan.is_empty() {
         let mut results: Vec<Binary> = to_scan
             .par_iter()
-            .filter_map(|lib| {
-                match parse(lib, &mut cache.as_ref().map(Arc::clone)) {
-                    Ok(bins) => Some(bins),
-                    Err(err) => {
-                        eprintln!(
-                            "Failed to parse {} for {}: {}",
-                            lib.display(),
-                            binary.file.display(),
-                            err
-                        );
-                        None
-                    }
+            .filter_map(|lib| match parse(lib, &mut cache.clone()) {
+                Ok(bins) => Some(bins),
+                Err(err) => {
+                    eprintln!(
+                        "Failed to parse {} for {}: {}",
+                        lib.display(),
+                        binary.file.display(),
+                        err
+                    );
+                    None
                 }
             })
             .flatten()
@@ -640,7 +638,7 @@ fn walk(
 #[cfg(all(feature = "maps", target_os = "linux"))]
 fn parse_process_libraries(
     process: &sysinfo::Process,
-    cache: &mut Option<Cache>,
+    cache: &Option<Cache>,
 ) -> Result<Vec<Binary>, std::io::Error> {
     Ok(Process::parse_maps(process.pid().as_u32() as usize)?
         .into_iter()
@@ -657,7 +655,7 @@ fn parse_process_libraries(
                     match file_name.strip_suffix(" (deleted)") {
                         Some(s) => {
                             let mut pb = PathBuf::from(
-                                p.parent().unwrap_or(Path::new("/")),
+                                p.parent().unwrap_or_else(|| Path::new("/")),
                             );
                             pb.push(s);
                             Either::Left(pb)
@@ -672,7 +670,7 @@ fn parse_process_libraries(
         .unique()
         .par_bridge()
         .filter_map(|p| {
-            parse(&p, &mut cache.as_ref().map(Arc::clone))
+            parse(&p, &mut cache.clone())
                 .map_err(|err| {
                     if let ParseError::IO(ref e) = err {
                         if e.kind() == ErrorKind::NotFound
@@ -698,7 +696,7 @@ fn parse_process_libraries(
 #[cfg(not(all(feature = "maps", target_os = "linux")))]
 fn parse_process_libraries(
     _process: &sysinfo::Process,
-    _cache: &mut Option<Cache>,
+    _cache: &Option<Cache>,
 ) -> Result<Vec<Binary>, std::io::Error> {
     Err(std::io::Error::new(
         ErrorKind::Unsupported,
@@ -743,7 +741,7 @@ where
                                 if scan_dynlibs {
                                     parse_process_libraries(
                                         process,
-                                        &mut Some(Arc::clone(&cache)),
+                                        &Some(Arc::clone(&cache)),
                                     )
                                     .ok()
                                 } else {
diff --git a/src/proc.rs b/src/proc.rs
@@ -78,7 +78,7 @@ pub struct Region {
 }
 #[cfg(all(feature = "maps", any(target_os = "linux", target_os = "windows")))]
 impl Region {
-    pub fn new(start: usize, end: usize) -> Self {
+    pub const fn new(start: usize, end: usize) -> Self {
         Self { start, end }
     }
 }
@@ -270,10 +270,10 @@ impl fmt::Display for MapEntry {
                     self.region.start, self.region.end, self.flags
                 )
                 .red(),
-                match &self.pathname {
-                    Some(pathname) => pathname.display().to_string().red(),
-                    None => String::new().red(),
-                }
+                self.pathname.as_ref().map_or_else(
+                    || String::new().red(),
+                    |pathname| pathname.display().to_string().red()
+                )
             )
         } else {
             write!(
@@ -282,10 +282,9 @@ impl fmt::Display for MapEntry {
                 self.region.start,
                 self.region.end,
                 self.flags,
-                match &self.pathname {
-                    Some(pathname) => pathname.display().to_string(),
-                    None => String::new(),
-                }
+                self.pathname.as_ref().map_or_else(String::new, |pathname| {
+                    pathname.display().to_string()
+                })
             )
         }
     }
@@ -366,7 +365,7 @@ impl Process {
         binary: Binary,
         libraries: Option<Vec<Binary>>,
     ) -> Self {
-        match Process::parse_maps(pid) {
+        match Self::parse_maps(pid) {
             Ok(maps) => Self { pid, binary, maps: Some(maps), libraries },
             Err(e) => {
                 eprintln!(

Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,7 @@ pub struct Region {`
`78`	`78`	`}`
`79`	`79`	`#[cfg(all(feature = "maps", any(target_os = "linux", target_os = "windows")))]`
`80`	`80`	`impl Region {`
`81`		`- pub fn new(start: usize, end: usize) -> Self {`
	`81`	`+ pub const fn new(start: usize, end: usize) -> Self {`
`82`	`82`	`Self { start, end }`
`83`	`83`	`}`
`84`	`84`	`}`
`@@ -270,10 +270,10 @@ impl fmt::Display for MapEntry {`
`270`	`270`	`self.region.start, self.region.end, self.flags`
`271`	`271`	`)`
`272`	`272`	`.red(),`
`273`		`- match &self.pathname {`
`274`		`- Some(pathname) => pathname.display().to_string().red(),`
`275`		`- None => String::new().red(),`
`276`		`- }`
	`273`	`+ self.pathname.as_ref().map_or_else(`
	`274`	`+ \|\| String::new().red(),`
	`275`	`+ \|pathname\| pathname.display().to_string().red()`
	`276`	`+ )`
`277`	`277`	`)`
`278`	`278`	`} else {`
`279`	`279`	`write!(`
`@@ -282,10 +282,9 @@ impl fmt::Display for MapEntry {`
`282`	`282`	`self.region.start,`
`283`	`283`	`self.region.end,`
`284`	`284`	`self.flags,`
`285`		`- match &self.pathname {`
`286`		`- Some(pathname) => pathname.display().to_string(),`
`287`		`- None => String::new(),`
`288`		`- }`
	`285`	`+ self.pathname.as_ref().map_or_else(String::new, \|pathname\| {`
	`286`	`+ pathname.display().to_string()`
	`287`	`+ })`
`289`	`288`	`)`
`290`	`289`	`}`
`291`	`290`	`}`
`@@ -366,7 +365,7 @@ impl Process {`
`366`	`365`	`binary: Binary,`
`367`	`366`	`libraries: Option<Vec<Binary>>,`
`368`	`367`	`) -> Self {`
`369`		`- match Process::parse_maps(pid) {`
	`368`	`+ match Self::parse_maps(pid) {`
`370`	`369`	`Ok(maps) => Self { pid, binary, maps: Some(maps), libraries },`
`371`	`370`	`Err(e) => {`
`372`	`371`	`eprintln!(`