Address clippy warnings in wrapper source code

Author: 9prady9

src/algorithm/mod.rs

@@ -1524,14 +1524,12 @@ mod tests {
         println!("reduction of bool matrix: {:?}", sum_all(&b));
 
         println!(
-            "reduction of complex f32 matrix after replacing nan with {}: {:?}",
-            1.0,
+            "reduction of complex f32 matrix after replacing nan with 1.0: {:?}",
             product_nan_all(&a, 1.0)
         );
 
         println!(
-            "reduction of bool matrix after replacing nan with {}: {:?}",
-            0.0,
+            "reduction of bool matrix after replacing nan with 0.0: {:?}",
             sum_nan_all(&b, 0.0)
         );
     }

src/core/array.rs

@@ -252,7 +252,7 @@ where
                 dims.get().as_ptr() as *const c_longlong,
                 strides.get().as_ptr() as *const c_longlong,
                 aftype as c_uint,
-                1 as c_uint,
+                1_u32,
             );
             HANDLE_ERROR(AfError::from(err_val));
             temp.into()
@@ -482,7 +482,7 @@ where
     }
 
     /// Returns the native FFI handle for Rust object `Array`
-    pub unsafe fn get(&self) -> af_array {
+    pub(crate) unsafe fn get(&self) -> af_array {
         self.handle
     }
 
@@ -644,6 +644,11 @@ where
     /// Get the device pointer and lock the buffer in memory manager
     ///
     /// The device pointer is not freed by memory manager until unlock is called.
+    ///
+    /// # Safety
+    ///
+    /// Using the function returns a pointer(CPU)/GPU-memory-pointer(CUDA)/cl_mem(OpenCL).
+    /// Use this function only when you know what to do further with returned object.
     pub unsafe fn device_ptr(&self) -> void_ptr {
         let mut temp: void_ptr = std::ptr::null_mut();
         let err_val = af_get_device_ptr(&mut temp as *mut void_ptr, self.handle);
@@ -792,10 +797,7 @@ pub fn print_gen<T: HasAfEnum>(msg: String, input: &Array<T>, precision: Option<
         let err_val = af_print_array_gen(
             emptystring.to_bytes_with_nul().as_ptr() as *const c_char,
             input.get(),
-            match precision {
-                Some(p) => p,
-                None => 4,
-            } as c_int,
+            precision.unwrap_or(4),
         );
         HANDLE_ERROR(AfError::from(err_val));
     }

src/core/data.rs

@@ -577,12 +577,11 @@ where
             // of only two more axes can be provided. Hence the below condition.
             assert!(left_over_new_axes.len() <= 2);
 
-            for a_idx in 0..left_over_new_axes.len() {
-                new_axes[2 + a_idx] = left_over_new_axes[a_idx];
-            }
+            new_axes[2..(left_over_new_axes.len() + 2)].clone_from_slice(&left_over_new_axes[..]);
         }
         None => {
-            for a_idx in 2..4 {
+            let left_over_indices: Vec<usize> = (2..4).collect();
+            for a_idx in left_over_indices {
                 new_axes[a_idx] = a_idx as u64;
             }
         }

src/core/device.rs

@@ -112,10 +112,10 @@ pub fn info_string(verbose: bool) -> String {
 /// # Return Values
 /// A tuple of `String` indicating the name, platform, toolkit and compute.
 pub fn device_info() -> (String, String, String, String) {
-    let mut name = [0 as c_char; 64];
-    let mut platform = [0 as c_char; 10];
-    let mut toolkit = [0 as c_char; 64];
-    let mut compute = [0 as c_char; 10];
+    let mut name: [c_char; 64] = [0; 64];
+    let mut platform: [c_char; 10] = [0; 10];
+    let mut toolkit: [c_char; 64] = [0; 64];
+    let mut compute: [c_char; 10] = [0; 10];
     unsafe {
         let err_val = af_device_info(
             &mut name[0],
@@ -320,6 +320,12 @@ pub fn sync(device: i32) {
 }
 
 /// Allocate non-pageable memory on HOST memory
+///
+/// # Safety
+///
+/// Non-pageable memory allocations should be done by users
+/// who understand the consequences of such allocations on other
+/// tasks running on the system.
 pub unsafe fn alloc_pinned(bytes: usize) -> void_ptr {
     let mut out: void_ptr = std::ptr::null_mut();
     let err_val = af_alloc_pinned(&mut out as *mut void_ptr, bytes as dim_t);
@@ -328,6 +334,12 @@ pub unsafe fn alloc_pinned(bytes: usize) -> void_ptr {
 }
 
 /// Free the pointer returned by [alloc_pinned](./fn.alloc_pinned.html)
+///
+/// # Safety
+///
+/// This function is intended to be called on pointers that were earlier
+/// allocated using [alloc_pinned](./fn.alloc_pinned.html). Any other values
+/// passed as argument would result in undefined behavior.
 pub unsafe fn free_pinned(ptr: void_ptr) {
     let err_val = af_free_pinned(ptr);
     HANDLE_ERROR(AfError::from(err_val));

src/core/index.rs

@@ -169,10 +169,7 @@ where
                 idxr.get(),
                 &SeqInternal::from_seq(self) as *const SeqInternal,
                 dim as dim_t,
-                match is_batch {
-                    Some(value) => value,
-                    None => false,
-                },
+                is_batch.unwrap_or(false),
             );
             HANDLE_ERROR(AfError::from(err_val));
         }
@@ -230,7 +227,7 @@ impl<'object> Indexer<'object> {
     }
 
     /// Get native(ArrayFire) resource handle
-    pub unsafe fn get(&self) -> af_index_t {
+    unsafe fn get(&self) -> af_index_t {
         self.handle
     }
 }

src/core/random.rs

@@ -143,10 +143,7 @@ impl RandomEngine {
             let err_val = af_create_random_engine(
                 &mut temp as *mut af_random_engine,
                 rengine as c_uint,
-                match seed {
-                    Some(s) => s,
-                    None => 0,
-                } as u64_t,
+                seed.unwrap_or(0u64),
             );
             HANDLE_ERROR(AfError::from(err_val));
             RandomEngine { handle: temp }
@@ -194,7 +191,7 @@ impl RandomEngine {
     }
 
     /// Returns the native FFI handle for Rust object `RandomEngine`
-    pub unsafe fn get(&self) -> af_random_engine {
+    unsafe fn get(&self) -> af_random_engine {
         self.handle
     }
 }
@@ -274,7 +271,7 @@ pub fn get_default_random_engine() -> RandomEngine {
         let mut handle: af_random_engine = std::ptr::null_mut();
         err_val = af_retain_random_engine(&mut handle as *mut af_random_engine, temp);
         HANDLE_ERROR(AfError::from(err_val));
-        RandomEngine { handle: handle }
+        RandomEngine { handle }
     }
 }