cleanup all clippy warnings (#215)

Author: gkorland

examples/hello.rs

@@ -18,10 +18,10 @@ fn hello_mul(_: &Context, args: Vec<RedisString>) -> RedisResult {
 
     let product = nums.iter().product();
 
-    let mut response = Vec::from(nums);
+    let mut response = nums;
     response.push(product);
 
-    return Ok(response.into());
+    Ok(response.into())
 }
 
 fn hello_err(ctx: &Context, args: Vec<RedisString>) -> RedisResult {

examples/load_unload.rs

@@ -5,7 +5,7 @@ use redis_module::{Context, LogLevel, RedisString, Status};
 
 static mut GLOBAL_STATE: Option<String> = None;
 
-fn init(ctx: &Context, args: &Vec<RedisString>) -> Status {
+fn init(ctx: &Context, args: &[RedisString]) -> Status {
     let (before, after) = unsafe {
         let before = GLOBAL_STATE.clone();
         GLOBAL_STATE.replace(format!("Args passed: {}", args.join(", ")));

examples/timer.rs

@@ -27,7 +27,7 @@ fn timer_info(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
     let (remaining, data): (_, &MyData) = ctx.get_timer_info(timer_id)?;
     let reply = format!("Remaining: {:?}, data: {:?}", remaining, data);
 
-    return Ok(reply.into());
+    Ok(reply.into())
 }
 
 fn timer_stop(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
@@ -37,7 +37,7 @@ fn timer_stop(ctx: &Context, args: Vec<RedisString>) -> RedisResult {
     let data: MyData = ctx.stop_timer(timer_id)?;
     let reply = format!("Data: {:?}", data);
 
-    return Ok(reply.into());
+    Ok(reply.into())
 }
 
 //////////////////////////////////////////////////////

src/context/mod.rs

@@ -263,8 +263,9 @@ impl Context {
         self.ctx
     }
 
+    /// # Safety
     #[cfg(feature = "experimental-api")]
-    pub fn export_shared_api(
+    pub unsafe fn export_shared_api(
         &self,
         func: *const ::std::os::raw::c_void,
         name: *const ::std::os::raw::c_char,
@@ -279,7 +280,7 @@ impl Context {
         event: &str,
         keyname: &RedisString,
     ) -> raw::Status {
-        raw::notify_keyspace_event(self.ctx, event_type, event, keyname)
+        unsafe { raw::notify_keyspace_event(self.ctx, event_type, event, keyname) }
     }
 
     /// Returns the redis version either by calling RedisModule_GetServerVersion API,

src/context/thread_safe.rs

@@ -25,16 +25,16 @@ impl Deref for ContextGuard {
 /// A ThreadSafeContext can either be bound to a blocked client, or detached from any client.
 pub struct DetachedFromClient;
 
-pub struct ThreadSafeContext<B> {
+pub struct ThreadSafeContext<B: Send> {
     pub(crate) ctx: *mut raw::RedisModuleCtx,
 
     /// This field is only used implicitly by `Drop`, so avoid a compiler warning
     #[allow(dead_code)]
     blocked_client: B,
 }
 
-unsafe impl<B> Send for ThreadSafeContext<B> {}
-unsafe impl<B> Sync for ThreadSafeContext<B> {}
+unsafe impl<B: Send> Send for ThreadSafeContext<B> {}
+unsafe impl<B: Send> Sync for ThreadSafeContext<B> {}
 
 impl ThreadSafeContext<DetachedFromClient> {
     pub fn new() -> Self {
@@ -69,7 +69,7 @@ impl ThreadSafeContext<BlockedClient> {
     }
 }
 
-impl<B> ThreadSafeContext<B> {
+impl<B: Send> ThreadSafeContext<B> {
     /// All other APIs require locking the context, so we wrap it in a way
     /// similar to `std::sync::Mutex`.
     pub fn lock(&self) -> ContextGuard {
@@ -79,7 +79,7 @@ impl<B> ThreadSafeContext<B> {
     }
 }
 
-impl<B> Drop for ThreadSafeContext<B> {
+impl<B: Send> Drop for ThreadSafeContext<B> {
     fn drop(&mut self) {
         unsafe { raw::RedisModule_FreeThreadSafeContext.unwrap()(self.ctx) };
     }

src/macros.rs

@@ -122,7 +122,7 @@ macro_rules! redis_module {
 
         #[no_mangle]
         #[allow(non_snake_case)]
-        pub extern "C" fn RedisModule_OnLoad(
+        pub unsafe extern "C" fn RedisModule_OnLoad(
             ctx: *mut $crate::raw::RedisModuleCtx,
             argv: *mut *mut $crate::raw::RedisModuleString,
             argc: std::os::raw::c_int,

src/raw.rs

@@ -607,32 +607,27 @@ pub fn add_info_field_long_long(
     }
 }
 
+/// # Safety
 #[cfg(feature = "experimental-api")]
-pub fn export_shared_api(
+pub unsafe fn export_shared_api(
     ctx: *mut RedisModuleCtx,
     func: *const ::std::os::raw::c_void,
     name: *const ::std::os::raw::c_char,
 ) {
-    unsafe { RedisModule_ExportSharedAPI.unwrap()(ctx, name, func as *mut ::std::os::raw::c_void) };
+    RedisModule_ExportSharedAPI.unwrap()(ctx, name, func as *mut ::std::os::raw::c_void);
 }
 
+/// # Safety
 #[cfg(feature = "experimental-api")]
-pub fn notify_keyspace_event(
+pub unsafe fn notify_keyspace_event(
     ctx: *mut RedisModuleCtx,
     event_type: NotifyEvent,
     event: &str,
     keyname: &RedisString,
 ) -> Status {
     let event = CString::new(event).unwrap();
-    unsafe {
-        RedisModule_NotifyKeyspaceEvent.unwrap()(
-            ctx,
-            event_type.bits,
-            event.as_ptr(),
-            keyname.inner,
-        )
+    RedisModule_NotifyKeyspaceEvent.unwrap()(ctx, event_type.bits, event.as_ptr(), keyname.inner)
         .into()
-    }
 }
 
 #[cfg(feature = "experimental-api")]