Clippy pedantic (#163)

* add next_str

(cherry picked from commit 693ac9d)

* clean some pedantic warnings

Author: gkorland

src/alloc.rs

@@ -8,10 +8,10 @@ pub struct RedisAlloc;
 unsafe impl GlobalAlloc for RedisAlloc {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         let size = (layout.size() + layout.align() - 1) & (!(layout.align() - 1));
-        raw::RedisModule_Alloc.unwrap()(size) as *mut u8
+        raw::RedisModule_Alloc.unwrap()(size).cast::<u8>()
     }
 
     unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
-        raw::RedisModule_Free.unwrap()(ptr as *mut c_void)
+        raw::RedisModule_Free.unwrap()(ptr.cast::<c_void>())
     }
 }

src/context/mod.rs

@@ -53,12 +53,18 @@ impl Context {
         self.log(LogLevel::Warning, message);
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_AutoMemory` is missing in redismodule.h
     pub fn auto_memory(&self) {
         unsafe {
             raw::RedisModule_AutoMemory.unwrap()(self.ctx);
         }
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_IsKeysPositionRequest` is missing in redismodule.h
     pub fn is_keys_position_request(&self) -> bool {
         // We want this to be available in tests where we don't have an actual Redis to call
         if cfg!(feature = "test") {
@@ -70,6 +76,9 @@ impl Context {
         result != 0
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_KeyAtPos` is missing in redismodule.h
     pub fn key_at_pos(&self, pos: i32) {
         // TODO: This will crash redis if `pos` is out of range.
         // Think of a way to make this safe by checking the range.
@@ -125,6 +134,9 @@ impl Context {
         }
     }
 
+    /// # Panics
+    ///
+    /// Will panic if methods used are missing in redismodule.h
     pub fn reply(&self, r: RedisResult) -> raw::Status {
         match r {
             Ok(RedisValue::Integer(v)) => unsafe {

src/key.rs

@@ -42,11 +42,14 @@ impl RedisKey {
         RedisKey { ctx, key_inner }
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_ModuleTypeGetValue` is missing in redismodule.h
     pub fn get_value<T>(&self, redis_type: &RedisType) -> Result<Option<&T>, RedisError> {
         verify_type(self.key_inner, redis_type)?;
 
         let value =
-            unsafe { raw::RedisModule_ModuleTypeGetValue.unwrap()(self.key_inner) as *mut T };
+            unsafe { raw::RedisModule_ModuleTypeGetValue.unwrap()(self.key_inner).cast::<T>() };
 
         if value.is_null() {
             return Ok(None);
@@ -57,6 +60,9 @@ impl RedisKey {
         Ok(Some(value))
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_KeyType` is missing in redismodule.h
     pub fn key_type(&self) -> raw::KeyType {
         unsafe { raw::RedisModule_KeyType.unwrap()(self.key_inner) }.into()
     }
@@ -247,11 +253,17 @@ impl RedisKeyWritable {
         }
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_DeleteKey` is missing in redismodule.h
     pub fn delete(&self) -> RedisResult {
         unsafe { raw::RedisModule_DeleteKey.unwrap()(self.key_inner) };
         REDIS_OK
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_KeyType` is missing in redismodule.h
     pub fn key_type(&self) -> raw::KeyType {
         unsafe { raw::RedisModule_KeyType.unwrap()(self.key_inner) }.into()
     }
@@ -268,13 +280,16 @@ impl RedisKeyWritable {
         RedisKeyWritable { ctx, key_inner }
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_ModuleTypeGetValue` is missing in redismodule.h    
     pub fn get_value<'a, 'b, T>(
         &'a self,
         redis_type: &RedisType,
     ) -> Result<Option<&'b mut T>, RedisError> {
         verify_type(self.key_inner, redis_type)?;
         let value =
-            unsafe { raw::RedisModule_ModuleTypeGetValue.unwrap()(self.key_inner) as *mut T };
+            unsafe { raw::RedisModule_ModuleTypeGetValue.unwrap()(self.key_inner).cast::<T>() };
 
         if value.is_null() {
             return Ok(None);
@@ -284,9 +299,12 @@ impl RedisKeyWritable {
         Ok(Some(value))
     }
 
+    /// # Panics
+    ///
+    /// Will panic if `RedisModule_ModuleTypeSetValue` is missing in redismodule.h
     pub fn set_value<T>(&self, redis_type: &RedisType, value: T) -> Result<(), RedisError> {
         verify_type(self.key_inner, redis_type)?;
-        let value = Box::into_raw(Box::new(value)) as *mut c_void;
+        let value = Box::into_raw(Box::new(value)).cast::<c_void>();
         let status: raw::Status = unsafe {
             raw::RedisModule_ModuleTypeSetValue.unwrap()(
                 self.key_inner,
@@ -358,7 +376,7 @@ where
 
     /// Provides an iterator over the multi-get results in the form of (field-name, field-value)
     /// pairs. The type of field-name elements is the same as that passed to the original multi-
-    /// get call, while the field-value elements may be of any type for which a RedisString `Into`
+    /// get call, while the field-value elements may be of any type for which a `RedisString` `Into`
     /// conversion is implemented.  
     ///
     /// # Examples
@@ -462,6 +480,10 @@ fn to_raw_mode(mode: KeyMode) -> raw::KeyMode {
     }
 }
 
+/// # Panics
+///
+/// Will panic if `RedisModule_KeyType` or `RedisModule_ModuleTypeGetType` are missing in redismodule.h
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub fn verify_type(key_inner: *mut raw::RedisModuleKey, redis_type: &RedisType) -> RedisResult {
     let key_type: KeyType = unsafe { raw::RedisModule_KeyType.unwrap()(key_inner) }.into();
 

src/native_types.rs

@@ -29,6 +29,7 @@ impl RedisType {
         }
     }
 
+    #[allow(clippy::not_unsafe_ptr_arg_deref)]
     pub fn create_data_type(&self, ctx: *mut raw::RedisModuleCtx) -> Result<(), &str> {
         if self.name.len() != 9 {
             let msg = "Redis requires the length of native type names to be exactly 9 characters";
@@ -64,6 +65,7 @@ impl RedisType {
 }
 
 // TODO: Move to raw
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
 pub fn redis_log(ctx: *mut raw::RedisModuleCtx, msg: &str) {
     let level = CString::new("notice").unwrap(); // FIXME reuse this
     let msg = CString::new(msg).unwrap();