Prepare for Edition 2024.

Author: kennytm

src/cli.rs

@@ -509,7 +509,7 @@ pub fn run(args: Args, span_registry: &mut Registry) -> Result<(), S<Error>> {
         env.write_table_schema()?;
     }
 
-    let meta_seed = args.seed.unwrap_or_else(|| OsRng.gen());
+    let meta_seed = args.seed.unwrap_or_else(|| OsRng.r#gen());
     let show_progress = !args.quiet;
     if show_progress {
         println!("Using seed: {meta_seed}");
@@ -682,13 +682,13 @@ impl RngName {
     /// Creates an RNG engine given the name. The RNG engine instance will be seeded from `src`.
     fn create(self, src: &mut rand_hc::Hc128Rng) -> Box<dyn RngCore + Send> {
         match self {
-            Self::ChaCha12 => Box::new(rand_chacha::ChaCha12Rng::from_seed(src.gen())),
-            Self::ChaCha20 => Box::new(rand_chacha::ChaCha20Rng::from_seed(src.gen())),
-            Self::Hc128 => Box::new(rand_hc::Hc128Rng::from_seed(src.gen())),
-            Self::Isaac => Box::new(rand_isaac::IsaacRng::from_seed(src.gen())),
-            Self::Isaac64 => Box::new(rand_isaac::Isaac64Rng::from_seed(src.gen())),
-            Self::XorShift => Box::new(rand_xorshift::XorShiftRng::from_seed(src.gen())),
-            Self::Pcg32 => Box::new(rand_pcg::Pcg32::from_seed(src.gen())),
+            Self::ChaCha12 => Box::new(rand_chacha::ChaCha12Rng::from_seed(src.r#gen())),
+            Self::ChaCha20 => Box::new(rand_chacha::ChaCha20Rng::from_seed(src.r#gen())),
+            Self::Hc128 => Box::new(rand_hc::Hc128Rng::from_seed(src.r#gen())),
+            Self::Isaac => Box::new(rand_isaac::IsaacRng::from_seed(src.r#gen())),
+            Self::Isaac64 => Box::new(rand_isaac::Isaac64Rng::from_seed(src.r#gen())),
+            Self::XorShift => Box::new(rand_xorshift::XorShiftRng::from_seed(src.r#gen())),
+            Self::Pcg32 => Box::new(rand_pcg::Pcg32::from_seed(src.r#gen())),
             Self::Step => Box::new(StepRng::new(src.next_u64(), src.next_u64() | 1)),
         }
     }
@@ -906,7 +906,7 @@ impl<'a> FormatWriter<'a> {
     fn path(&self) -> PathBuf {
         let mut path_prefix = self.path_prefix.as_os_str().to_owned();
         if let Some((_, counter)) = &self.target_size_and_counter {
-            path_prefix.push(&counter.to_string());
+            path_prefix.push(counter.to_string());
         }
         path_prefix.push(".");
         path_prefix.push(self.path_extension);

src/eval.rs

@@ -108,7 +108,7 @@ pub struct Schema<'a> {
     column_name_ranges: &'a [Range<usize>],
 }
 
-impl<'a> Schema<'a> {
+impl Schema<'_> {
     /// Returns an iterator of column names associated with the table.
     pub fn column_names(&self) -> impl Iterator<Item = &str> + '_ {
         self.column_name_ranges.iter().map(move |r| &self.content[r.clone()])
@@ -386,7 +386,7 @@ impl Compiled {
 
             C::RandUuid => {
                 // we will loss 6 bits but that's still uniform.
-                let g = state.rng.gen::<[u16; 8]>();
+                let g = state.rng.r#gen::<[u16; 8]>();
                 format!(
                     "{:04x}{:04x}-{:04x}-4{:03x}-{:04x}-{:04x}{:04x}{:04x}",
                     g[0],

src/format.rs

@@ -245,7 +245,7 @@ impl Options {
             Value::Null => writer.write_all(self.null_string.as_bytes()),
             Value::Number(number) => number.write_io(writer, &self.true_string, &self.false_string),
             Value::Bytes(bytes) => self.write_sql_bytes(writer, bytes),
-            Value::Timestamp(timestamp) => write_timestamp(writer, "'", &timestamp),
+            Value::Timestamp(timestamp) => write_timestamp(writer, "'", timestamp),
             Value::Interval(interval) => write_interval(writer, "'", *interval),
             Value::Array(array) => {
                 writer.write_all(b"ARRAY[")?;
@@ -372,7 +372,7 @@ impl Format for CsvFormat<'_> {
             Value::Null => writer.write_all(self.0.null_string.as_bytes()),
             Value::Number(number) => number.write_io(writer, &self.0.true_string, &self.0.false_string),
             Value::Bytes(bytes) => self.write_bytes(writer, bytes),
-            Value::Timestamp(timestamp) => write_timestamp(writer, "", &timestamp),
+            Value::Timestamp(timestamp) => write_timestamp(writer, "", timestamp),
             Value::Interval(interval) => write_interval(writer, "", *interval),
             Value::Array(array) => {
                 writer.write_all(b"{")?;

src/lib.rs

@@ -58,6 +58,9 @@
     clippy::verbose_file_reads
 )]
 #![allow(
+    edition_2024_expr_fragment_specifier,
+    if_let_rescope,
+    tail_expr_drop_order,
     clippy::module_name_repetitions,
     clippy::must_use_candidate,
     clippy::missing_errors_doc,

src/number.rs

@@ -29,7 +29,7 @@ macro_rules! impl_from_integer_for_number {
         impl From<$ty> for Number {
             // ALLOW_REASON: for simplicity of the macro.
             // we should be using `v.into()` but usize & isize do not impl Into<i128>.
-            #[allow(trivial_numeric_casts)]
+            #[allow(trivial_numeric_casts, clippy::cast_lossless)]
             fn from(v: $ty) -> Self {
                 Self(N::I(v as i128))
             }
@@ -81,6 +81,7 @@ macro_rules! impl_try_from_number_for_integer {
                 match n.0 {
                     N::B(v) => Ok(v.into()),
                     N::I(v) => Self::try_from(v).map_err(|_| NumberError::Overflow),
+                    #[allow(clippy::cast_lossless, clippy::cast_possible_truncation, clippy::cast_sign_loss, clippy::cast_precision_loss)]
                     N::F(v) if Self::MIN as f64 <= v && v <= Self::MAX as f64 => Ok(v as $ty),
                     _ => Err(NumberError::Overflow),
                 }

src/schemagen_cli.rs

@@ -103,7 +103,7 @@ type ColumnGenerator = fn(Dialect, &mut dyn RngCore) -> Column;
 
 fn gen_int_column(dialect: Dialect, rng: &mut dyn RngCore) -> Column {
     let bytes = rng.gen_range(0..8);
-    let unsigned = rng.gen::<bool>();
+    let unsigned = rng.r#gen::<bool>();
     // ALLOW_REASON: different database engines sharing the same name for different type
     // does not mean we should combine them into the same arm.
     #[allow(clippy::match_same_arms)]
@@ -240,7 +240,7 @@ fn gen_datetime_column(dialect: Dialect, _: &mut dyn RngCore) -> Column {
 }
 
 fn gen_nullable_bool_column(_: Dialect, rng: &mut dyn RngCore) -> Column {
-    let p = rng.gen::<f64>();
+    let p = rng.r#gen::<f64>();
     Column {
         ty: "boolean".to_owned(),
         expr: format!("CASE WHEN rand.bool({p}) THEN '' || rand.bool(0.5) END"),
@@ -287,8 +287,8 @@ static GENERATORS: [ColumnGenerator; 9] = [
 ];
 
 fn gen_column(dialect: Dialect, rng: &mut dyn RngCore) -> Column {
-    let gen = GENERATORS.choose(rng).unwrap();
-    gen(dialect, rng)
+    let r#gen = GENERATORS.choose(rng).unwrap();
+    r#gen(dialect, rng)
 }
 
 struct IndexAppender<'a> {
@@ -407,7 +407,7 @@ fn gen_table(dialect: Dialect, rng: &mut dyn RngCore, target_size: f64) -> Table
         schema,
         target_size,
         rows_count: (rows_count as u64).max(1),
-        seed: rng.gen(),
+        seed: rng.r#gen(),
     }
 }
 
@@ -447,7 +447,7 @@ pub fn print_script(args: &Args) {
     let schema_name = QName::parse(&args.schema_name).expect("valid schema name");
     let quoted_schema_name = shlex::try_quote(&args.schema_name).expect("valid schema name");
 
-    let meta_seed = args.seed.unwrap_or_else(|| OsRng.gen());
+    let meta_seed = args.seed.unwrap_or_else(|| OsRng.r#gen());
     println!(
         "#!/bin/sh\n\
          # generated by dbschemagen v{} ({}), using seed {}\n\n\

src/value.rs

@@ -296,6 +296,7 @@ macro_rules! impl_try_from_value {
 
             fn try_from(value: Value) -> Result<Self, Self::Error> {
                 if let Value::Number(n) = value {
+                    #[allow(irrefutable_let_patterns)]
                     if let Ok(v) = n.try_into() {
                         return Ok(v);
                     }
@@ -310,7 +311,9 @@ macro_rules! impl_try_from_value {
             fn try_from(value: Value) -> Result<Self, Self::Error> {
                 match value {
                     Value::Null => return Ok(None),
-                    Value::Number(n) => {
+                    Value::Number(n) =>
+                    {
+                        #[allow(irrefutable_let_patterns)]
                         if let Ok(v) = n.try_into() {
                             return Ok(Some(v));
                         }