Fix clippy lints (#456)

* Fix clippy warnings in redismodule-rs-macros-internals

* Fix clippy warnings in redismodule-rs-macros

* chore: Format

* Fix clippy warnings in main crate

Author: LukeMathWalker

redismodule-rs-macros-internals/src/api_versions.rs

@@ -61,11 +61,11 @@ pub(crate) fn get_feature_flags(
     (
         all_lower_versions
             .into_iter()
-            .map(|s| quote!(feature = #s).into())
+            .map(|s| quote!(feature = #s))
             .collect(),
         all_upper_versions
             .into_iter()
-            .map(|s| quote!(feature = #s).into())
+            .map(|s| quote!(feature = #s))
             .collect(),
     )
 }

redismodule-rs-macros-internals/src/lib.rs

@@ -72,7 +72,7 @@ pub fn api(item: TokenStream) -> TokenStream {
                 // if we do not have a version mapping, we assume the API exists and return the minimum version.
                 let api_version = API_VERSION_MAPPING
                     .get(&item.to_string())
-                    .map(|v| *v)
+                    .copied()
                     .unwrap_or(*API_OLDEST_VERSION);
                 api_version.max(min_api_version)
             });

redismodule-rs-macros/src/lib.rs

@@ -433,20 +433,20 @@ pub fn info_command_handler(_attr: TokenStream, item: TokenStream) -> TokenStrea
 /// # Notes
 ///
 /// 1. The name of the struct is taken "as is", so if it starts with
-/// a capital letter (written in the "Upper Camel Case"), like in this
-/// example - `Info`, then it will be compiled into a string prefixed
-/// with the module name, ending up being `"module_name_Info"`-named
-/// section. The fields of the struct are also prefixed with the module
-/// name, so the `field_1` will be prefixed with `module_name_` as well.
+///    a capital letter (written in the "Upper Camel Case"), like in this
+///    example - `Info`, then it will be compiled into a string prefixed
+///    with the module name, ending up being `"module_name_Info"`-named
+///    section. The fields of the struct are also prefixed with the module
+///    name, so the `field_1` will be prefixed with `module_name_` as well.
 /// 2. In dictionaries, the type of dictionaries supported varies,
-/// for now it is [`std::collections::BTreeMap`] and
-/// [`std::collections::HashMap`].
+///    for now it is [`std::collections::BTreeMap`] and
+///    [`std::collections::HashMap`].
 /// 3. In dictionaries, the value type can be anything that can be
-/// converted into an object of type
-/// [`redis_module::InfoContextBuilderFieldBottomLevelValue`], for
-/// example, a [`std::string::String`] or [`u64`]. Please, refer to
-/// [`redis_module::InfoContextBuilderFieldBottomLevelValue`] for more
-/// information.
+///    converted into an object of type
+///    [`redis_module::InfoContextBuilderFieldBottomLevelValue`], for
+///    example, a [`std::string::String`] or [`u64`]. Please, refer to
+///    [`redis_module::InfoContextBuilderFieldBottomLevelValue`] for more
+///    information.
 #[proc_macro_derive(InfoSection)]
 pub fn info_section(item: TokenStream) -> TokenStream {
     info_section::info_section(item)

src/configuration.rs

@@ -227,6 +227,7 @@ extern "C" fn i64_configuration_get<T: ConfigurationValue<i64> + 'static>(
     private_data.get_val()
 }
 
+#[expect(clippy::too_many_arguments)]
 pub fn register_i64_configuration<T: ConfigurationValue<i64>>(
     ctx: &Context,
     name: &str,

src/context/commands.rs

@@ -203,11 +203,11 @@ pub struct FindKeysNum {
 /// After Redis finds the location from where it needs to start looking for keys,
 /// Redis will start finding keys base on the information in this enum.
 /// There are 2 possible options:
-/// 1. Range -   Required to specify additional 3 more values, `last_key`, `steps`, and `limit`.
-/// 2. Keynum -  Required to specify additional 3 more values, `keynumidx`, `firstkey`, and `keystep`.
-///              Redis will consider the argument at `keynumidx` as an indicator
-///              to the number of keys that will follow. Then it will start
-///              from `firstkey` and jump each `keystep` to find the keys.
+/// 1. Range - Required to specify additional 3 more values, `last_key`, `steps`, and `limit`.
+/// 2. Keynum - Required to specify additional 3 more values, `keynumidx`, `firstkey`, and `keystep`.
+///    Redis will consider the argument at `keynumidx` as an indicator
+///    to the number of keys that will follow. Then it will start
+///    from `firstkey` and jump each `keystep` to find the keys.
 pub enum FindKeys {
     Range(FindKeysRange),
     Keynum(FindKeysNum),
@@ -358,6 +358,7 @@ pub struct RedisModuleCommandArg {
 }
 
 impl RedisModuleCommandArg {
+    #[expect(clippy::too_many_arguments)]
     pub fn new(
         name: String,
         type_: u32,
@@ -402,6 +403,7 @@ pub struct CommandInfo {
 }
 
 impl CommandInfo {
+    #[expect(clippy::too_many_arguments)]
     pub fn new(
         name: String,
         flags: Option<String>,

src/context/defrag.rs

@@ -29,11 +29,14 @@ unsafe impl RedisLockIndicator for DefragContext {}
 
 impl DefragContext {
     /// Creates a new [`DefragContext`] from a poiter to [`raw::RedisModuleDefragCtx`].
-    /// The function is considered unsafe because the provided pointer
-    /// must be a valid pointer to [`raw::RedisModuleDefragCtx`], and the Redis GIL must be held.
     /// The function is exposed for users that wants to implement the defrag function
     /// on their module datatype, they can use this function to create [`DefragContext`]
     /// that can be used in a safely manner.
+    ///
+    /// # Safety
+    ///
+    /// The function is considered unsafe because the provided pointer
+    /// must be a valid pointer to [`raw::RedisModuleDefragCtx`], and the Redis GIL must be held.
     /// Notice that the returned [`DefragContext`] borrows the pointer to [`raw::RedisModuleDefragCtx`]
     /// so it can not outlive it (this means that it should not be used once the defrag callback ends).
     pub unsafe fn new(defrag_ctx: *mut raw::RedisModuleDefragCtx) -> DefragContext {
@@ -120,12 +123,14 @@ impl DefragContext {
     /// If defragmentation was not necessary, NULL is returned and the operation has
     /// no other effect.
     ///
-    /// If a non-NULL value is returned, the caller should use the new pointer instead
-    /// of the old one and update any reference to the old pointer, which must not
-    /// be used again.
+    /// # Safety
     ///
     /// The function is unsafe because it is assumed that the pointer is valid and previusly
     /// allocated. It is considered undefined if this is not the case.
+    ///
+    /// If a non-NULL value is returned, the caller should use the new pointer instead
+    /// of the old one and update any reference to the old pointer, which must not
+    /// be used again.
     pub unsafe fn defrag_realloc<T>(&self, mut ptr: *mut T) -> *mut T {
         let new_ptr: *mut T = RedisModule_DefragAlloc
             .expect("RedisModule_DefragAlloc should be available.")(

src/raw.rs

@@ -206,12 +206,13 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////
 
-pub const FMT: *const c_char = b"v\0".as_ptr().cast::<c_char>();
+pub const FMT: *const c_char = c"v".as_ptr().cast::<c_char>();
 
 // REDISMODULE_HASH_DELETE is defined explicitly here because bindgen cannot
 // parse typecasts in C macro constants yet.
 // See https://github.com/rust-lang/rust-bindgen/issues/316
-pub const REDISMODULE_HASH_DELETE: *const RedisModuleString = 1 as *const RedisModuleString;
+pub const REDISMODULE_HASH_DELETE: *const RedisModuleString =
+    std::ptr::dangling::<RedisModuleString>();
 
 // Helper functions for the raw bindings.