Fmt

src/config.rs

@@ -537,7 +537,7 @@ impl Config {
         }
 
         config.subprocesses = matches.occurrences_of("subprocesses") > 0;
-        config.command = subcommand.to_owned();
+        subcommand.clone_into(&mut config.command);
 
         // options that can be shared between subcommands
         config.pid = matches
@@ -639,14 +639,14 @@ mod tests {
         );
 
         // test out overriding these params by setting flags
-        assert_eq!(config.include_idle, false);
-        assert_eq!(config.gil_only, false);
-        assert_eq!(config.include_thread_ids, false);
+        assert!(!config.include_idle);
+        assert!(!config.gil_only);
+        assert!(!config.include_thread_ids);
 
         let config_flags = get_config("py-spy r -p 1234 -o foo --idle --gil --threads").unwrap();
-        assert_eq!(config_flags.include_idle, true);
-        assert_eq!(config_flags.gil_only, true);
-        assert_eq!(config_flags.include_thread_ids, true);
+        assert!(config_flags.include_idle);
+        assert!(config_flags.gil_only);
+        assert!(config_flags.include_thread_ids);
     }
 
     #[test]

src/coredump.rs

@@ -435,7 +435,7 @@ mod test {
         // we won't have the python binary for the core dump here,
         // so we can't (yet) figure out the interpreter address & version.
         // Manually specify here to test out instead
-        let core = CoreDump::new(&get_coredump_path("python_3_9_threads")).unwrap();
+        let core = CoreDump::new(get_coredump_path("python_3_9_threads")).unwrap();
         let version = Version {
             major: 3,
             minor: 9,

src/cython.rs

@@ -34,7 +34,7 @@ impl SourceMaps {
         if let Some(map) = self.maps.get(&frame.filename) {
             if let Some(map) = map {
                 if let Some((file, line)) = map.lookup(line) {
-                    frame.filename = file.clone();
+                    frame.filename.clone_from(file);
                     frame.line = *line as i32;
                 }
             }

src/main.rs

@@ -434,7 +434,7 @@ fn sample_pyroscope(pid: remoteprocess::Pid, config: &Config) -> Result<(), Erro
                 });
             }
 
-            if let Some(process_info) = trace.process_info.as_ref().map(|x| x) {
+            if let Some(process_info) = trace.process_info.as_ref() {
                 trace.frames.push(process_info.to_frame());
                 let mut parent = process_info.parent.as_ref();
                 while parent.is_some() {
@@ -446,7 +446,7 @@ fn sample_pyroscope(pid: remoteprocess::Pid, config: &Config) -> Result<(), Erro
             }
 
             samples += 1;
-            output.increment(&trace)?;
+            output.increment(trace)?;
         }
 
         send_samples += 1;

src/python_data_access.rs

@@ -469,7 +469,7 @@ pub mod tests {
         };
         unsafe {
             let ptr = &mut ret as *mut AllocatedPyASCIIObject as *mut u8;
-            let dst = ptr.offset(std::mem::size_of::<PyASCIIObject>() as isize);
+            let dst = ptr.add(std::mem::size_of::<PyASCIIObject>());
             copy_nonoverlapping(bytes.as_ptr(), dst, bytes.len());
         }
         ret

src/sampler.rs

@@ -56,7 +56,7 @@ impl Sampler {
                     spy
                 }
                 Err(e) => {
-                    if initialized_tx.send(Err(e)).is_err() {}
+                    initialized_tx.send(Err(e)).is_err();
                     return;
                 }
             };
@@ -219,7 +219,7 @@ impl Sampler {
                     let process = process_info
                         .entry(pid)
                         .or_insert_with(|| get_process_info(pid, &spies).map(|p| Arc::new(*p)));
-                    trace.process_info = process.clone();
+                    trace.process_info.clone_from(process);
                 }
 
                 // Send the collected info back
@@ -308,7 +308,7 @@ impl PythonSpyThread {
                 }
                 Err(e) => {
                     warn!("Failed to profile python from process {}: {}", pid, e);
-                    if initialized_tx.send(Err(e)).is_err() {}
+                    initialized_tx.send(Err(e)).is_err();
                     return;
                 }
             };

src/speedscope.rs

@@ -233,7 +233,7 @@ impl Stats {
 
         self.samples
             .entry(key)
-            .or_insert_with(std::vec::Vec::new)
+            .or_default()
             .push(frame_indices);
         let subprocesses = self.config.subprocesses;
         self.thread_name_map.entry(key).or_insert_with(|| {

src/timer.rs

@@ -2,7 +2,6 @@ use std::time::{Duration, Instant};
 #[cfg(windows)]
 use winapi::um::timeapi;
 
-use rand;
 use rand_distr::{Distribution, Exp};
 
 /// Timer is an iterator that sleeps an appropriate amount of time between iterations