style: format, migrate to 2024 Edition, and fix remaining clippy lints (#31)

* style: run (patched) rustfmt

I was originally perplexed as to why the crate wasn't already formatted,
but quickly found out why... Though the PR seems to have languished for
some time, I've run a patched version of rustfmt that completes without
crashing: rust-lang/rustfmt#6396

* style: fix `mismatched_lifetime_syntaxes` lint

* style: remove unnecessary macro imports

This is a strange case — I had to look this up myself! Because you have
a `#[macro_use]` above the `params` module in `lib.rs`, all of the
macros in `params.rs` are automatically made available crate-wide. This
import of the macro in `scan_properties.rs` is therefore redundant!

The same logic applies to `impl_param_described`.

https://lukaswirth.dev/tlborm/decl-macros/minutiae/scoping.html

* style: fix clippy `derivable_impls`

For `enum`s, you can add a tag and `#[derive(Default)]` instead of
manually implementing the same code:
https://doc.rust-lang.org/std/default/trait.Default.html#enums

* style: fix clippy `single_match`

* style: fix clippy `redundant_closure`

* style: clippy fix `unnecessary_unwrap`

* style: clippy fix `manual_is_multiple_of`

NOTE: This method was added in a recent version of Rust (1.87.0), so
changing to this code means that our minimum supported Rust version
would become that! If you'd rather keep compatibility with
older-than-stable versions of Rust, we should leave this unchanged!

* chore(edition): run `cargo update`

* style(edition): run `cargo --fix edition`

Performs some automatic migration to the 2024 edition of Rust. Will be
followed by a cleanup commit.

* style(edition): bump to Rust 2024

* style(edition): reformat using (patched) rustfmt

This is now a different, newer PR that supports the 2024 edition:
rust-lang/rustfmt#6630

* style(edition): `expr_2021` -> `expr` in macros

The 2024 edition changed `expr`s to accept `const` and `_` expressions,
but because no macros in `mzdata` included any `const` or `_` keywords
in their syntax, no change needs to be made.

* style(edition): `match` back to `if let`

None of the migrated code seemed to depend on any exact `Drop` timing,
so the overly-cautious `if let` -> `match` migration was unnecessary.

* style(edition): change `gen` to `this_generation`

In the 2024 edition, `gen` became a reserved Rust keyword. Using `r#gen`
is still possible, but probably not best practice, so I've renamed the
old `gen` variables.

* style: fix clippy `let_and_return`

* style: fix clippy `collapsible_if`

Author: TheLostLambda

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "mzdata"
 version = "0.59.3"
-edition = "2021"
+edition = "2024"
 keywords = ['mass-spectrometry', 'mzml', 'mgf']
 
 categories = ["science", "parser-implementations", "data-structures"]

Cargo.toml

@@ -1,4 +1,4 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{Criterion, black_box, criterion_group, criterion_main};
 
 use std::fs;
 

benches/mzml.rs

@@ -48,7 +48,8 @@ async fn scan_file(reader: &mut mzml::AsyncMzMLReader<fs::File>) {
 #[tokio::main(flavor = "multi_thread", worker_threads = 10)]
 async fn main() -> io::Result<()> {
     let path = path::PathBuf::from(
-        env::args().nth(1)
+        env::args()
+            .nth(1)
             .expect("Please pass an MS data file path"),
     );
     if let Some(ext) = path.extension() {

examples/async_mzcat.rs

@@ -5,8 +5,8 @@ use std::io::{self, Seek};
 use std::time::Instant;
 
 use mzdata::io::{
-    infer_from_stream, MassSpectrometryFormat, PreBufferedStream, RestartableGzDecoder,
-    SpectrumSource,
+    MassSpectrometryFormat, PreBufferedStream, RestartableGzDecoder, SpectrumSource,
+    infer_from_stream,
 };
 use mzdata::{MGFReader, MzMLReader};
 

examples/from_stdin.rs

@@ -34,8 +34,16 @@ fn main() -> io::Result<()> {
     };
 
     // dbg!(spectrum);
-    println!("ID: {}; Index: {}; Time: {}", spectrum.id(), spectrum.index(), spectrum.start_time());
-    println!("Num data points: {}", spectrum.raw_arrays().unwrap().mzs().unwrap().len());
+    println!(
+        "ID: {}; Index: {}; Time: {}",
+        spectrum.id(),
+        spectrum.index(),
+        spectrum.start_time()
+    );
+    println!(
+        "Num data points: {}",
+        spectrum.raw_arrays().unwrap().mzs().unwrap().len()
+    );
 
     Ok(())
 }

examples/get_scan_by.rs

@@ -6,7 +6,7 @@ use std::env;
 use std::io;
 use std::process::exit;
 
-use mzdata::io::{infer_format, infer_from_stream, PreBufferedStream};
+use mzdata::io::{PreBufferedStream, infer_format, infer_from_stream};
 
 fn main() -> io::Result<()> {
     let input = env::args().nth(1).unwrap_or_else(|| {

examples/infer_format.rs

@@ -2,7 +2,7 @@ use std::time;
 use std::{env, io, path};
 
 use mzdata::spectrum::MultiLayerSpectrum;
-use mzdata::{prelude::*, MZReader};
+use mzdata::{MZReader, prelude::*};
 use rayon::prelude::*;
 
 fn scan_file<R: MZFileReader + Iterator<Item = MultiLayerSpectrum> + Send>(reader: &mut R) {

examples/mzcat.rs

@@ -2,27 +2,31 @@ use std::any::Any;
 use std::fs::File;
 use std::io;
 use std::path::PathBuf;
-use std::sync::{mpsc::sync_channel, Arc, atomic::{AtomicU64, Ordering as AtomicOrdering}};
+use std::sync::{
+    Arc,
+    atomic::{AtomicU64, Ordering as AtomicOrdering},
+    mpsc::sync_channel,
+};
 use std::thread;
 use std::time;
 
 use clap::Parser;
 
 use log::info;
 use mzdata::io::MassSpectrometryFormat;
-use mzdata::io::{checksum_file, MassSpectrometryReadWriteProcess, Sink, Source};
-use mzdata::meta::custom_software_name;
+use mzdata::io::{MassSpectrometryReadWriteProcess, Sink, Source, checksum_file};
 use mzdata::meta::Software;
+use mzdata::meta::custom_software_name;
 use mzdata::meta::{DataProcessing, ProcessingMethod, SourceFile};
 use mzdata::params::ControlledVocabulary;
 use mzdata::prelude::*;
 
-use mzdata::spectrum::bindata::BinaryCompressionType;
+use mzdata::MzMLWriter;
 use mzdata::spectrum::ArrayType;
 use mzdata::spectrum::ArrayType::IntensityArray;
 use mzdata::spectrum::ArrayType::MZArray;
 use mzdata::spectrum::BinaryDataArrayType;
-use mzdata::MzMLWriter;
+use mzdata::spectrum::bindata::BinaryCompressionType;
 use mzpeaks::{CentroidPeak, DeconvolutedPeak};
 
 fn compression_parser(compression: &str) -> Result<BinaryCompressionType, String> {
@@ -32,9 +36,11 @@ fn compression_parser(compression: &str) -> Result<BinaryCompressionType, String
         compression.to_string()
     };
 
-    BinaryCompressionType::COMPRESSION_METHODS.iter().find(|x| {
-        x.as_param().unwrap().name() == compression
-    }).copied().ok_or_else(|| compression.to_string())
+    BinaryCompressionType::COMPRESSION_METHODS
+        .iter()
+        .find(|x| x.as_param().unwrap().name() == compression)
+        .copied()
+        .ok_or_else(|| compression.to_string())
 }
 
 #[derive(Debug, Clone, Parser)]
@@ -44,7 +50,7 @@ pub struct MZConvert {
     #[arg()]
     pub outpath: String,
 
-    #[arg(short='b', long, default_value_t=8192)]
+    #[arg(short = 'b', long, default_value_t = 8192)]
     pub buffer_size: usize,
 
     #[arg(long, value_parser=compression_parser, default_value="zlib compression")]
@@ -91,7 +97,7 @@ impl MZConvert {
         mut writer: W,
     ) -> io::Result<()> {
         let (send, recv) = sync_channel(self.buffer_size);
-        let buffered= Arc::new(AtomicU64::default());
+        let buffered = Arc::new(AtomicU64::default());
         let buffered_w = Arc::clone(&buffered);
         let reader_handle = thread::spawn(move || {
             reader.enumerate().for_each(|(i, s)| {
@@ -111,9 +117,10 @@ impl MZConvert {
             for s in recv.iter() {
                 let i = s.index();
                 buffered_w.fetch_sub(1, AtomicOrdering::SeqCst);
-                writer.write_owned(s).inspect_err(|e| {
-                    log::error!("Failed to write spectrum {i}: {e}")
-                }).unwrap();
+                writer
+                    .write_owned(s)
+                    .inspect_err(|e| log::error!("Failed to write spectrum {i}: {e}"))
+                    .unwrap();
             }
             writer.close().unwrap();
         });
@@ -190,7 +197,6 @@ impl MZConvert {
                     self.ion_mobility_compression,
                 );
             }
-
         }
     }
 }
@@ -251,7 +257,7 @@ impl MassSpectrometryReadWriteProcess<CentroidPeak, DeconvolutedPeak> for MZConv
                 Default::default()
             } else {
                 info!("Computing checksum for {}", pb.display());
-                
+
                 checksum_file(&pb)?
             };
             let has_already = reader

examples/mzconvert.rs

@@ -8,12 +8,12 @@ use std::time;
 
 use std::sync::mpsc::sync_channel;
 
+use mzdata::MZReader;
 use mzdata::io::Source;
 use mzdata::prelude::*;
 use mzdata::spectrum::{
     DeconvolutedSpectrum, MultiLayerSpectrum, RefPeakDataLevel, SignalContinuity, SpectrumLike,
 };
-use mzdata::MZReader;
 
 struct MSDataFileSummary {
     pub start_time: f64,
@@ -22,7 +22,7 @@ struct MSDataFileSummary {
     pub charge_table: HashMap<i32, usize>,
     pub peak_charge_table: HashMap<u8, HashMap<i32, usize>>,
     pub peak_mode_table: HashMap<SignalContinuity, usize>,
-    pub has_ion_mobility: bool
+    pub has_ion_mobility: bool,
 }
 
 impl Default for MSDataFileSummary {
@@ -112,11 +112,10 @@ impl MSDataFileSummary {
         let start = time::Instant::now();
         let (sender, receiver) = sync_channel(2usize.pow(12));
         let read_handle = spawn(move || {
-            reader.into_iter()
+            reader
+                .into_iter()
                 .enumerate()
-                .for_each(|(i, scan)| {
-                    sender.send((i, scan)).unwrap()
-                });
+                .for_each(|(i, scan)| sender.send((i, scan)).unwrap());
         });
         let i = receiver.iter().fold(0, |_, (i, scan)| {
             if i % 10000 == 0 && i > 0 {
@@ -134,7 +133,10 @@ impl MSDataFileSummary {
         read_handle.join().unwrap();
         let end = time::Instant::now();
         let elapsed = end - start;
-        println!("{:0.3} seconds elapsed, handled {i} spectra", elapsed.as_secs_f64());
+        println!(
+            "{:0.3} seconds elapsed, handled {i} spectra",
+            elapsed.as_secs_f64()
+        );
     }
 
     pub fn write_out(&self) {