fix: make build and cargo clippy happy (benfred#795)

Signed-off-by: yihong0618 <zouzou0208@gmail.com>

Author: yihong0618

src/binary_parser.rs

@@ -125,7 +125,7 @@ pub fn parse_binary(filename: &Path, addr: u64, size: u64) -> Result<BinaryInfo,
                 .filter(|header| {
                     strtab
                         .get_at(header.sh_name)
-                        .map_or(true, |name| name == ".bss")
+                        .is_none_or(|name| name == ".bss")
                 })
                 // if we have multiple sections here, take the largest
                 .max_by_key(|header| header.sh_size)
@@ -171,11 +171,10 @@ pub fn parse_binary(filename: &Path, addr: u64, size: u64) -> Result<BinaryInfo,
                 bss_end = bss_header.sh_addr + bss_header.sh_size;
             }
 
-            let pyruntime_header = elf.section_headers.iter().find(|header| {
-                strtab
-                    .get_at(header.sh_name)
-                    .map_or(false, |name| name == ".PyRuntime")
-            });
+            let pyruntime_header = elf
+                .section_headers
+                .iter()
+                .find(|header| strtab.get_at(header.sh_name) == Some(".PyRuntime"));
 
             let mut pyruntime_addr = 0;
             let mut pyruntime_size = 0;

src/config.rs

@@ -87,7 +87,7 @@ impl std::str::FromStr for FileFormat {
                 return Ok(*variant);
             }
         }
-        Err(format!("Invalid fileformat: {}", s))
+        Err(format!("Invalid fileformat: {s}"))
     }
 }
 

src/console_viewer.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use std::io;
-use std::io::{Read, Write};
+use std::io::{BufReader, Read, Write};
 use std::sync::{atomic, Arc, Mutex};
 use std::thread;
 use std::vec::Vec;
@@ -40,14 +40,17 @@ impl ConsoleViewer {
         let input_running = running.clone();
         let input_options = options.clone();
         thread::spawn(move || {
+            let stdin = std::io::stdin();
+            let mut buf_reader = BufReader::new(stdin);
+            let mut buffer = [0u8; 1];
             while input_running.load(atomic::Ordering::Relaxed) {
                 // TODO: there isn't a non-blocking version of stdin, so this will capture the
                 // next keystroke after the ConsoleViewer object has been destroyed =(
-                if let Some(Ok(key)) = std::io::stdin().bytes().next() {
+                if buf_reader.read_exact(&mut buffer).is_ok() {
                     let mut options = input_options.lock().unwrap();
                     options.dirty = true;
                     let previous_usage = options.usage;
-                    match key as char {
+                    match buffer[0] as char {
                         'R' | 'r' => options.reset = true,
                         'L' | 'l' => options.show_linenumbers = !options.show_linenumbers,
                         'X' | 'x' => options.usage = false,
@@ -173,7 +176,7 @@ impl ConsoleViewer {
         if let Some(delay) = self.stats.last_delay {
             let late_rate = self.stats.late_samples as f64 / self.stats.overall_samples as f64;
             if late_rate > 0.10 && delay > std::time::Duration::from_secs(1) {
-                let msg = format!("{:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate.", delay);
+                let msg = format!("{delay:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate.");
                 out!("{}", style(msg).red());
                 header_lines += 1;
             }
@@ -327,7 +330,7 @@ impl ConsoleViewer {
     pub fn increment_error(&mut self, err: &Error) -> Result<(), Error> {
         self.maybe_reset();
         self.stats.errors += 1;
-        self.stats.last_error = Some(format!("{}", err));
+        self.stats.last_error = Some(format!("{err}"));
         self.increment_common()
     }
 
@@ -492,13 +495,13 @@ impl Stats {
 // helper function for formatting time values (hide decimals for larger values)
 fn display_time(val: f64) -> String {
     if val > 1000.0 {
-        format!("{:.0}", val)
+        format!("{val:.0}")
     } else if val >= 100.0 {
-        format!("{:.1}", val)
+        format!("{val:.1}")
     } else if val >= 1.0 {
-        format!("{:.2}", val)
+        format!("{val:.2}")
     } else {
-        format!("{:.3}", val)
+        format!("{val:.3}")
     }
 }
 

src/flamegraph.rs

@@ -76,7 +76,7 @@ impl Flamegraph {
     fn get_lines(&self) -> Vec<String> {
         self.counts
             .iter()
-            .map(|(k, v)| format!("{} {}", k, v))
+            .map(|(k, v)| format!("{k} {v}"))
             .collect()
     }
 

src/main.rs

@@ -62,7 +62,7 @@ fn sample_console(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
 
     let display = match remoteprocess::Process::new(pid)?.cmdline() {
         Ok(cmdline) => cmdline.join(" "),
-        Err(_) => format!("Pid {}", pid),
+        Err(_) => format!("Pid {pid}"),
     };
 
     let mut console =
@@ -81,7 +81,7 @@ fn sample_console(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
     }
 
     if !config.subprocesses {
-        println!("\nprocess {} ended", pid);
+        println!("\nprocess {pid} ended");
     }
     Ok(())
 }
@@ -163,7 +163,7 @@ fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
                     None => String::from("unknown"),
                 },
             };
-            format!("{}-{}.{}", name, local_time, ext)
+            format!("{name}-{local_time}.{ext}")
         }
     };
 
@@ -237,12 +237,12 @@ fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
                     let now = std::time::Instant::now();
                     if now - last_late_message > Duration::from_secs(1) {
                         last_late_message = now;
-                        println!("{}{:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate", lede, delay)
+                        println!("{lede}{delay:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate")
                     }
                 } else {
                     let term = console::Term::stdout();
                     term.move_cursor_up(2)?;
-                    println!("{:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate.", delay);
+                    println!("{delay:.2?} behind in sampling, results may be inaccurate. Try reducing the sampling rate.");
                     term.move_cursor_down(1)?;
                 }
             }
@@ -273,9 +273,9 @@ fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
             if config.include_thread_ids {
                 let threadid = trace.format_threadid();
                 let thread_fmt = if let Some(thread_name) = &trace.thread_name {
-                    format!("thread ({}): {}", threadid, thread_name)
+                    format!("thread ({threadid}): {thread_name}")
                 } else {
-                    format!("thread ({})", threadid)
+                    format!("thread ({threadid})")
                 };
                 trace.frames.push(Frame {
                     name: thread_fmt,
@@ -313,9 +313,9 @@ fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
 
         if config.duration == RecordDuration::Unlimited {
             let msg = if errors > 0 {
-                format!("Collected {} samples ({} errors)", samples, errors)
+                format!("Collected {samples} samples ({errors} errors)")
             } else {
-                format!("Collected {} samples", samples)
+                format!("Collected {samples} samples")
             };
             progress.set_message(msg);
         }
@@ -324,7 +324,7 @@ fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
     progress.finish();
     // write out a message here (so as not to interfere with progress bar) if we ended earlier
     if !exit_message.is_empty() {
-        println!("\n{}{}", lede, exit_message);
+        println!("\n{lede}{exit_message}");
     }
 
     {
@@ -335,8 +335,7 @@ fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
     match config.format.as_ref().unwrap() {
         FileFormat::flamegraph => {
             println!(
-                "{}Wrote flamegraph data to '{}'. Samples: {} Errors: {}",
-                lede, filename, samples, errors
+                "{lede}Wrote flamegraph data to '{filename}'. Samples: {samples} Errors: {errors}"
             );
             // open generated flame graph in the browser on OSX (theory being that on linux
             // you might be SSH'ed into a server somewhere and this isn't desired, but on
@@ -346,27 +345,21 @@ fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<(), Error>
         }
         FileFormat::speedscope => {
             println!(
-                "{}Wrote speedscope file to '{}'. Samples: {} Errors: {}",
-                lede, filename, samples, errors
+                "{lede}Wrote speedscope file to '{filename}'. Samples: {samples} Errors: {errors}"
             );
-            println!("{}Visit https://www.speedscope.app/ to view", lede);
+            println!("{lede}Visit https://www.speedscope.app/ to view");
         }
         FileFormat::raw => {
             println!(
-                "{}Wrote raw flamegraph data to '{}'. Samples: {} Errors: {}",
-                lede, filename, samples, errors
+                "{lede}Wrote raw flamegraph data to '{filename}'. Samples: {samples} Errors: {errors}"
             );
-            println!("{}You can use the flamegraph.pl script from https://github.com/brendangregg/flamegraph to generate a SVG", lede);
+            println!("{lede}You can use the flamegraph.pl script from https://github.com/brendangregg/flamegraph to generate a SVG");
         }
         FileFormat::chrometrace => {
             println!(
-                "{}Wrote chrome trace to '{}'. Samples: {} Errors: {}",
-                lede, filename, samples, errors
-            );
-            println!(
-                "{}Visit chrome://tracing or https://ui.perfetto.dev/ to view",
-                lede
+                "{lede}Wrote chrome trace to '{filename}'. Samples: {samples} Errors: {errors}"
             );
+            println!("{lede}Visit chrome://tracing or https://ui.perfetto.dev/ to view");
         }
     };
 
@@ -468,7 +461,7 @@ fn pyspy_main() -> Result<(), Error> {
         if config.capture_output && (!success || result.is_err()) {
             let mut buffer = String::new();
             if process_output.read_to_string(&mut buffer).is_ok() {
-                eprintln!("{}", buffer);
+                eprintln!("{buffer}");
             }
         }
 
@@ -516,10 +509,10 @@ fn main() {
             }
         }
 
-        eprintln!("Error: {}", err);
+        eprintln!("Error: {err}");
         for (i, suberror) in err.chain().enumerate() {
             if i > 0 {
-                eprintln!("Reason: {}", suberror);
+                eprintln!("Reason: {suberror}");
             }
         }
         std::process::exit(1);

src/python_bindings/v3_11_0.rs

@@ -48,9 +48,7 @@ where
     pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
         debug_assert!(index / 8 < core::mem::size_of::<Storage>());
         let byte_index = index / 8;
-        let byte = unsafe {
-            *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
-        };
+        let byte = unsafe { *(core::ptr::addr_of!((*this).storage) as *const u8).add(byte_index) };
         Self::extract_bit(byte, index)
     }
     #[inline]
@@ -78,9 +76,7 @@ where
     pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
         debug_assert!(index / 8 < core::mem::size_of::<Storage>());
         let byte_index = index / 8;
-        let byte = unsafe {
-            (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
-        };
+        let byte = unsafe { (core::ptr::addr_of_mut!((*this).storage) as *mut u8).add(byte_index) };
         unsafe { *byte = Self::change_bit(*byte, index, val) };
     }
     #[inline]

src/python_bindings/v3_12_0.rs

@@ -48,9 +48,7 @@ where
     pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
         debug_assert!(index / 8 < core::mem::size_of::<Storage>());
         let byte_index = index / 8;
-        let byte = unsafe {
-            *(core::ptr::addr_of!((*this).storage) as *const u8).offset(byte_index as isize)
-        };
+        let byte = unsafe { *(core::ptr::addr_of!((*this).storage) as *const u8).add(byte_index) };
         Self::extract_bit(byte, index)
     }
     #[inline]
@@ -78,9 +76,7 @@ where
     pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
         debug_assert!(index / 8 < core::mem::size_of::<Storage>());
         let byte_index = index / 8;
-        let byte = unsafe {
-            (core::ptr::addr_of_mut!((*this).storage) as *mut u8).offset(byte_index as isize)
-        };
+        let byte = unsafe { (core::ptr::addr_of_mut!((*this).storage) as *mut u8).add(byte_index) };
         unsafe { *byte = Self::change_bit(*byte, index, val) };
     }
     #[inline]

src/python_data_access.rs

@@ -142,7 +142,6 @@ pub fn copy_int<P: ProcessMemory>(process: &P, addr: usize) -> Result<i64, Error
 }
 
 /// Allows iteration of a python dictionary. Only supports python 3.6+ right now
-
 pub struct DictIterator<'a, P: 'a> {
     process: &'a P,
     entries_addr: usize,
@@ -386,7 +385,7 @@ where
         if value_type_name == "bool" {
             (if value > 0 { "True" } else { "False" }).to_owned()
         } else {
-            format!("{}", value)
+            format!("{value}")
         }
     };
 
@@ -415,7 +414,7 @@ where
         if let Some((offset, _)) = value.char_indices().nth((max_length - 5) as usize) {
             format!("\"{}...\"", &value[..offset])
         } else {
-            format!("\"{}\"", value)
+            format!("\"{value}\"")
         }
     } else if flags & PY_TPFLAGS_DICT_SUBCLASS != 0 {
         if version.major == 3 && version.minor >= 6 {
@@ -430,7 +429,7 @@ where
                     values.push("...".to_owned());
                     break;
                 }
-                values.push(format!("{}: {}", key, value));
+                values.push(format!("{key}: {value}"));
             }
             format!("{{{}}}", values.join(", "))
         } else {
@@ -488,10 +487,10 @@ where
             "numpy.int64" => format_obval::<i64, P>(addr, process)?,
             "numpy.float32" => format_obval::<f32, P>(addr, process)?,
             "numpy.float64" => format_obval::<f64, P>(addr, process)?,
-            _ => format!("<{} at 0x{:x}>", value_type_name, addr),
+            _ => format!("<{value_type_name} at 0x{addr:x}>"),
         }
     } else {
-        format!("<{} at 0x{:x}>", value_type_name, addr)
+        format!("<{value_type_name} at 0x{addr:x}>")
     };
 
     Ok(formatted)
@@ -519,7 +518,7 @@ where
     let base_addr = addr as *mut u32;
     let offset = std::mem::size_of::<crate::python_bindings::v3_7_0::PyObject>() as isize;
     let result = unsafe { process.copy_pointer(base_addr.byte_offset(offset) as *const T)? };
-    Ok(format!("{}", result))
+    Ok(format!("{result}"))
 }
 
 #[cfg(test)]

src/python_interpreters.rs

@@ -723,7 +723,7 @@ impl CodeObject for v3_10_0::PyCodeObject {
         let mut bytecode_address: i32 = 0;
         while (i + 1) < size {
             let delta: u8 = table[i];
-            let line_delta: i8 = unsafe { std::mem::transmute(table[i + 1]) };
+            let line_delta: i8 = table[i + 1] as i8;
             i += 2;
 
             if line_delta == -128 {

src/python_process_info.rs

@@ -623,8 +623,8 @@ where
             ..
         } => {
             let gil_ptr = interpreter_address + std::mem::offset_of!(v3_13_0::_is, ceval.gil);
-            let gil = process.copy_struct::<usize>(gil_ptr)?;
-            gil
+
+            process.copy_struct::<usize>(gil_ptr)?
         }
         Version {
             major: 3,
@@ -688,8 +688,7 @@ fn error_if_gil(config: &Config, version: &Version, msg: &str) -> Result<(), Err
         if !WARNED.load(std::sync::atomic::Ordering::Relaxed) {
             // only print this once
             eprintln!(
-                "Cannot detect GIL holding in version '{}' on the current platform (reason: {})",
-                version, msg
+                "Cannot detect GIL holding in version '{version}' on the current platform (reason: {msg})"
             );
             eprintln!("Please open an issue in https://github.com/benfred/py-spy with the Python version and your platform.");
             WARNED.store(true, std::sync::atomic::Ordering::Relaxed);