[All] Fix warnings/errors in new rust versions

widberg · widberg · commit 5feb893caf40 · 2025-08-18T21:55:31.000-04:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -14,12 +14,21 @@ rust-version = "1.85.0"
 bool_to_int_with_if = "warn"
 branches_sharing_code = "warn"
 comparison_chain = "warn"
+elidable_lifetime_names = "warn"
 equatable_if_let = "warn"
 flat_map_option = "warn"
 if_then_some_else_none = "warn"
+implicit_clone = "warn"
+manual_midpoint = "warn"
+non_std_lazy_statics = "warn"
+precedence_bits = "warn"
+redundant_test_prefix = "warn"
 redundant_type_annotations = "warn"
+return_and_then = "warn"
+single_option_map = "warn"
 str_to_string = "warn"
-string_to_string = "warn"
+unnecessary_debug_formatting = "warn"
+unnecessary_semicolon = "warn"
 use_self = "warn"
 used_underscore_binding = "warn"
 used_underscore_items = "warn"
diff --git a/bff-cli/src/lz.rs b/bff-cli/src/lz.rs
@@ -64,7 +64,7 @@ fn lz_internal<R: Read, W: Write>(
         LzAlgorithm::Arcode => arcode_compress_data_with_header_writer(&buf, &mut writer, endian)?,
         LzAlgorithm::Zlib => zlib_compress_data_with_header_writer(&buf, &mut writer, endian)?,
         LzAlgorithm::Gzip => gzip_compress_data_with_header_writer(&buf, &mut writer, endian)?,
-    };
+    }
 
     compressed.write_all(&writer.into_inner())?;
     Ok(())
diff --git a/bff-derive/src/generic_class.rs b/bff-derive/src/generic_class.rs
@@ -51,7 +51,7 @@ struct SpecificClass<'a> {
     is_complete: bool,
 }
 
-fn simple_parse(input: &DeriveInput) -> SpecificClass {
+fn simple_parse(input: &DeriveInput) -> SpecificClass<'_> {
     let attrs = &input.attrs;
     let name = &input.ident;
     let mut custom_name: Option<Ident> = None;
diff --git a/bff-derive/src/referenced_names.rs b/bff-derive/src/referenced_names.rs
@@ -81,93 +81,86 @@ pub fn derive_referenced_names(mut input: DeriveInput) -> TokenStream {
             }
         },
         Data::Enum(data) => {
-            let variants =
-                data.variants
-                    .iter()
-                    .map(|variant| {
-                        let variant_name = &variant.ident;
-                        does_not_have_skip_attr(&variant.attrs)
-                            .then(|| match &variant.fields {
-                                Fields::Named(named) => {
-                                    let (names, fields): (Vec<_>, Vec<_>) =
-                                        named
-                                            .named
-                                            .iter()
-                                            .map(|field| {
-                                                does_not_have_skip_attr(&field.attrs)
-                                            .then(|| {
-                                                let name = field.ident.as_ref().unwrap();
-                                                (name, quote! {
+            let variants = data
+                .variants
+                .iter()
+                .map(|variant| {
+                    let variant_name = &variant.ident;
+                    if does_not_have_skip_attr(&variant.attrs) {
+                        match &variant.fields {
+                            Fields::Named(named) => {
+                                let (names, fields): (Vec<_>, Vec<_>) = named
+                                    .named
+                                    .iter()
+                                    .map(|field| {
+                                        let name = field.ident.as_ref().unwrap();
+                                        if does_not_have_skip_attr(&field.attrs) {
+                                            (
+                                                name,
+                                                quote! {
                                                     #name.extend_referenced_names(names);
-                                                })
-                                            })
-                                            .unwrap_or_else(|| {
-                                                let name = field.ident.as_ref().unwrap();
-                                                (name, quote! {})
-                                            })
-                                            })
-                                            .unzip();
-
-                                    quote! {
-                                        #name::#variant_name { #(#names,)* } => {
-                                            #(#fields)*
+                                                },
+                                            )
+                                        } else {
+                                            (name, quote! {})
                                         }
+                                    })
+                                    .unzip();
+
+                                quote! {
+                                    #name::#variant_name { #(#names,)* } => {
+                                        #(#fields)*
                                     }
                                 }
-                                Fields::Unnamed(unnamed) => {
-                                    let (fields, names): (Vec<_>, Vec<_>) = unnamed
-                                        .unnamed
-                                        .iter()
-                                        .enumerate()
-                                        .map(|(i, field)| {
-                                            does_not_have_skip_attr(&field.attrs)
-                                                .then(|| {
-                                                    let ident = Ident::new(
-                                                        format!("field_{}", i).as_str(),
-                                                        variant.span(),
-                                                    );
-                                                    (
-                                                        quote! {
-                                                            #ident.extend_referenced_names(names);
-                                                        },
-                                                        ident,
-                                                    )
-                                                })
-                                                .unwrap_or_else(|| {
-                                                    let ident = Ident::new(
-                                                        format!("field_{}", i).as_str(),
-                                                        variant.span(),
-                                                    );
-                                                    (quote! {}, ident)
-                                                })
-                                        })
-                                        .unzip();
-
-                                    quote! {
-                                        #name::#variant_name(#(#names,)*) => {
-                                            #(#fields)*
+                            }
+                            Fields::Unnamed(unnamed) => {
+                                let (fields, names): (Vec<_>, Vec<_>) = unnamed
+                                    .unnamed
+                                    .iter()
+                                    .enumerate()
+                                    .map(|(i, field)| {
+                                        let ident = Ident::new(
+                                            format!("field_{}", i).as_str(),
+                                            variant.span(),
+                                        );
+                                        if does_not_have_skip_attr(&field.attrs) {
+                                            (
+                                                quote! {
+                                                    #ident.extend_referenced_names(names);
+                                                },
+                                                ident,
+                                            )
+                                        } else {
+                                            (quote! {}, ident)
                                         }
+                                    })
+                                    .unzip();
+
+                                quote! {
+                                    #name::#variant_name(#(#names,)*) => {
+                                        #(#fields)*
                                     }
                                 }
-                                Fields::Unit => {
-                                    quote! { #name::#variant_name => {} }
-                                }
-                            })
-                            .unwrap_or_else(|| {
+                            }
+                            Fields::Unit => {
                                 quote! { #name::#variant_name => {} }
-                            })
-                    })
-                    .collect::<Vec<_>>();
-
-            (!variants.is_empty())
-                .then(|| {
-                    quote! {
-                        match self {
-                            #(#variants)*
+                            }
                         }
+                    } else {
+                        quote! { #name::#variant_name => {} }
                     }
                 })
-                .unwrap_or_default()
+                .collect::<Vec<_>>();
+
+            if !variants.is_empty() {
+                quote! {
+                    match self {
+                        #(#variants)*
+                    }
+                }
+            } else {
+                Default::default()
+            }
         }
         Data::Union(_) => {
             unimplemented!()
diff --git a/bff-gui/src/views/sound.rs b/bff-gui/src/views/sound.rs
@@ -64,7 +64,7 @@ pub fn sound_view(
         let points: Vec<egui::Pos2> = data
             .iter()
             .enumerate()
-            .filter(|(i, _)| (i % 10 == 0))
+            .filter(|(i, _)| i % 10 == 0)
             .map(|(i, v)| {
                 let t = i as f32 / data.len() as f32;
                 to_screen * egui::pos2(t, *v as f32 / i16::MAX as f32)
diff --git a/bff/Cargo.toml b/bff/Cargo.toml
@@ -23,7 +23,6 @@ indexmap = { version = "2.0.0", features = ["serde"] }
 itertools = "0.14.0"
 lz4 = "1.24.0"
 num-traits = "0.2.15"
-once_cell = "1.18.0"
 pastey = "0.1.0"
 petgraph = "0.8.1"
 scanf = "1.2.1"
diff --git a/bff/src/bigfile/v1_06_63_02_pc/header.rs b/bff/src/bigfile/v1_06_63_02_pc/header.rs
@@ -74,6 +74,6 @@ pub struct Header {
     pub file_size: u32,
     #[brw(align_after = 2048)]
     #[br(try, map = |incredi_builder_string: FixedStringNull<128>| Some(incredi_builder_string.into()))]
-    #[bw(map = |incredi_builder_string: &Option<String>| incredi_builder_string.as_ref().map(|s| FixedStringNull::<128>::from(s.to_string())).unwrap_or(FixedStringNull::<128>::from(String::new())))]
+    #[bw(map = |incredi_builder_string: &Option<String>| incredi_builder_string.as_ref().map(|s| FixedStringNull::<128>::from(s.clone())).unwrap_or(FixedStringNull::<128>::from(String::new())))]
     pub incredi_builder_string: Option<String>,
 }
diff --git a/bff/src/class/mesh/v1_291_03_06_pc.rs b/bff/src/class/mesh/v1_291_03_06_pc.rs
@@ -34,16 +34,6 @@ struct PointsRelated2 {
     data: [u8; 4],
 }
 
-#[derive(BinRead, Debug, Serialize, BinWrite, Deserialize, JsonSchema, ReferencedNames)]
-struct Unknown1 {
-    unknown1: [u8; 8],
-}
-
-#[derive(BinRead, Debug, Serialize, BinWrite, Deserialize, JsonSchema, ReferencedNames)]
-struct Unknown2 {
-    unknown2: [u8; 12],
-}
-
 #[derive(BinRead, Debug, Serialize, BinWrite, Deserialize, JsonSchema, ReferencedNames)]
 struct Unknown5 {
     unknown8_count: u32,
diff --git a/bff/src/class/rot_shape/v1_06_63_02_pc.rs b/bff/src/class/rot_shape/v1_06_63_02_pc.rs
@@ -8,11 +8,6 @@ use crate::helpers::{DynArray, ResourceObjectLinkHeaderV1_06_63_02PC, Vec2f, Vec
 use crate::names::Name;
 use crate::traits::{Export, Import};
 
-#[derive(BinRead, BinWrite, Debug, Serialize, Deserialize, ReferencedNames, JsonSchema)]
-struct PointsRelated0 {
-    data: [u8; 12],
-}
-
 #[derive(BinRead, BinWrite, Debug, Serialize, Deserialize, ReferencedNames, JsonSchema)]
 struct PointsRelated1 {
     data: [u8; 16],
diff --git a/bff/src/lz/lzrs.rs b/bff/src/lz/lzrs.rs
@@ -191,17 +191,17 @@ impl Match {
             node.as_mut().unwrap().prev = self.prev;
             if !node.as_mut().unwrap().prev.is_null() {
                 node.as_mut().unwrap().prev.as_mut().unwrap().next = node;
-            };
+            }
             node.as_mut().unwrap().next = self;
             node.as_mut().unwrap().next.as_mut().unwrap().prev = node;
         }
     }
 
-    fn next(&self) -> Option<&mut Self> {
+    fn next(&mut self) -> Option<&mut Self> {
         unsafe { self.next.as_mut() }
     }
 
-    fn prev(&self) -> Option<&mut Self> {
+    fn prev(&mut self) -> Option<&mut Self> {
         unsafe { self.prev.as_mut() }
     }
 }
@@ -214,7 +214,7 @@ impl Packet {
         mut uncompressed_buffer_ptr: u64,
         mut window_index: u32,
         uncompressed_buffer: &[u8],
-        g_window_buffer: &[Match],
+        g_window_buffer: &mut [Match],
     ) -> bool {
         let mut remaining_length: u32 = (1 << self.match_length) + 2;
         let v20: u32 = 0x10000 >> self.match_length;
@@ -351,7 +351,7 @@ pub fn compress_data_writer(data: &[u8]) -> BinResult<()> {
                     uncompressed_buffer_ptr,
                     window_index,
                     &uncompressed_buffer,
-                    &g_window_buffer,
+                    &mut g_window_buffer,
                 ) {
                     return Some(i);
                 }
diff --git a/bff/src/names/mod.rs b/bff/src/names/mod.rs
@@ -7,14 +7,13 @@ use std::fmt::{Debug, Display, Formatter, Write as _};
 use std::hash::Hash;
 use std::io::{BufRead, Read, Seek, Write};
 use std::str::FromStr;
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 
 use binrw::{BinRead, BinResult, BinWrite, Endian};
 use const_power_of_two::PowerOfTwoUsize;
 use derive_more::{Display, From};
 use encoding_rs::WINDOWS_1252;
 use num_traits::AsPrimitive;
-use once_cell::sync::Lazy;
 use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
 use serde::{Deserialize, Deserializer, Serialize};
 use string_interner::backend::BucketBackend;
@@ -491,30 +490,14 @@ impl Names {
 
     pub fn get(&self, name: &Name) -> Option<&str> {
         match name {
-            Name::Asobo32(n) => self
-                .asobo32_names
-                .get(n)
-                .and_then(|x| self.strings.resolve(*x)),
-            Name::AsoboAlternate32(n) => self
-                .asobo_alternate32_names
-                .get(n)
-                .and_then(|x| self.strings.resolve(*x)),
-            Name::Kalisto32(n) => self
-                .kalisto32_names
-                .get(n)
-                .and_then(|x| self.strings.resolve(*x)),
-            Name::BlackSheep32(n) => self
-                .blacksheep32_names
-                .get(n)
-                .and_then(|x| self.strings.resolve(*x)),
-            Name::Asobo64(n) => self
-                .asobo64_names
-                .get(n)
-                .and_then(|x| self.strings.resolve(*x)),
-            Name::Ubisoft64(n) => self
-                .ubisoft64_names
-                .get(n)
-                .and_then(|x| self.strings.resolve(*x)),
+            Name::Asobo32(n) => self.strings.resolve(*self.asobo32_names.get(n)?),
+            Name::AsoboAlternate32(n) => {
+                self.strings.resolve(*self.asobo_alternate32_names.get(n)?)
+            }
+            Name::Kalisto32(n) => self.strings.resolve(*self.kalisto32_names.get(n)?),
+            Name::BlackSheep32(n) => self.strings.resolve(*self.blacksheep32_names.get(n)?),
+            Name::Asobo64(n) => self.strings.resolve(*self.asobo64_names.get(n)?),
+            Name::Ubisoft64(n) => self.strings.resolve(*self.ubisoft64_names.get(n)?),
         }
     }
 }
@@ -546,7 +529,7 @@ impl Default for Names {
 // and deserialize functions. Doing that with derive is a bit tricky though.
 // https://docs.rs/serde_state/latest/serde_state/ outdated.
 // Until this is done bff is not thread safe.
-static NAMES: Lazy<Mutex<Names>> = Lazy::new(|| Mutex::new(Names::default()));
+static NAMES: LazyLock<Mutex<Names>> = LazyLock::new(|| Mutex::new(Names::default()));
 
 pub fn names() -> &'static Mutex<Names> {
     &NAMES
diff --git a/bff/src/tsc/cps.rs b/bff/src/tsc/cps.rs
@@ -39,7 +39,7 @@ fn decode_cps_script() -> BinResult<String> {
                 match param {
                     Param::String(s) => script.push_str(format!(r#""{}""#, s).as_str()),
                     Param::Float(f) => script.push_str(f.to_string().as_str()),
-                };
+                }
             }
         }
         script.push('\n');
@@ -204,6 +204,7 @@ const CPS_VERSION: &[u8; 8] = b"OPAL_1.0";
 const CPS_FIRST_CHAR: u8 = b'O';
 const CPS_SEED_STEP: u8 = 37;
 
+#[allow(clippy::unbuffered_bytes)]
 #[binrw::parser(reader)]
 fn cps_crypt() -> BinResult<Vec<u8>> {
     let mut data = Vec::new();
diff --git a/bff/src/tsc/csc.rs b/bff/src/tsc/csc.rs
@@ -2,6 +2,7 @@ use std::io::{Read, Write};
 
 use crate::BffResult;
 
+#[allow(clippy::unbuffered_bytes)]
 pub fn csc_copy<R: Read, W: Write>(reader: R, writer: &mut W, key: u8) -> BffResult<()> {
     for byte in reader.bytes() {
         let byte = byte?;
diff --git a/justfile b/justfile

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ struct SpecificClass<'a> {`
`51`	`51`	`is_complete: bool,`
`52`	`52`	`}`
`53`	`53`
`54`		`-fn simple_parse(input: &DeriveInput) -> SpecificClass {`
	`54`	`+fn simple_parse(input: &DeriveInput) -> SpecificClass<'_> {`
`55`	`55`	`let attrs = &input.attrs;`
`56`	`56`	`let name = &input.ident;`
`57`	`57`	`let mut custom_name: Option<Ident> = None;`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,6 @@ pub struct Header {`
`74`	`74`	`pub file_size: u32,`
`75`	`75`	`#[brw(align_after = 2048)]`
`76`	`76`	`#[br(try, map = \|incredi_builder_string: FixedStringNull<128>\| Some(incredi_builder_string.into()))]`
`77`		`- #[bw(map = \|incredi_builder_string: &Option<String>\| incredi_builder_string.as_ref().map(\|s\| FixedStringNull::<128>::from(s.to_string())).unwrap_or(FixedStringNull::<128>::from(String::new())))]`
	`77`	`+ #[bw(map = \|incredi_builder_string: &Option<String>\| incredi_builder_string.as_ref().map(\|s\| FixedStringNull::<128>::from(s.clone())).unwrap_or(FixedStringNull::<128>::from(String::new())))]`
`78`	`78`	`pub incredi_builder_string: Option<String>,`
`79`	`79`	`}`