Fixed compiler and clippy warnings

Author: genbattle

onnxruntime-sys/build.rs

@@ -178,7 +178,7 @@ fn extract_zip(filename: &Path, outpath: &Path) {
         let mut file = archive.by_index(i).unwrap();
         #[allow(deprecated)]
         let outpath = outpath.join(file.sanitized_name());
-        if !(&*file.name()).ends_with('/') {
+        if !(file.name()).ends_with('/') {
             println!(
                 "File {} extracted to \"{}\" ({} bytes)",
                 i,

onnxruntime-sys/examples/c_api_sample.rs

@@ -278,19 +278,16 @@ fn main() {
 
     // score model & input tensor, get back output tensor
 
-    let input_node_names_cstring: Vec<std::ffi::CString> = input_node_names
+    let input_node_names_ptr: Vec<*const i8> = input_node_names
         .into_iter()
         .map(|n| std::ffi::CString::new(n).unwrap())
-        .collect();
-    let input_node_names_ptr: Vec<*const i8> = input_node_names_cstring
-        .into_iter()
         .map(|n| n.into_raw() as *const i8)
         .collect();
     let input_node_names_ptr_ptr: *const *const i8 = input_node_names_ptr.as_ptr();
 
     let output_node_names_cstring: Vec<std::ffi::CString> = output_node_names
-        .into_iter()
-        .map(|n| std::ffi::CString::new(n.clone()).unwrap())
+        .iter()
+        .map(|n| std::ffi::CString::new(n.to_owned()).unwrap())
         .collect();
     let output_node_names_ptr: Vec<*const i8> = output_node_names_cstring
         .iter()
@@ -341,8 +338,8 @@ fn main() {
     // NOTE: The C ONNX Runtime allocated the array, we shouldn't drop the vec
     //       but let C de-allocate instead.
     let floatarr_vec: Vec<f32> = unsafe { Vec::from_raw_parts(floatarr, 5, 5) };
-    for i in 0..5 {
-        println!("Score for class [{}] =  {}", i, floatarr_vec[i]);
+    for (i, class) in floatarr_vec.iter().enumerate() {
+        println!("Score for class [{}] =  {}", i, class);
     }
     std::mem::forget(floatarr_vec);
 
@@ -363,7 +360,7 @@ fn main() {
 }
 
 fn CheckStatus(g_ort: *const OrtApi, status: *const OrtStatus) -> Result<(), String> {
-    if status != std::ptr::null() {
+    if status.is_null() {
         let raw = unsafe { g_ort.as_ref().unwrap().GetErrorMessage.unwrap()(status) };
         Err(char_p_to_str(raw).unwrap().to_string())
     } else {

onnxruntime/Cargo.toml

@@ -31,7 +31,7 @@ ureq = { version = "2.1", optional = true }
 
 [dev-dependencies]
 image = "0.23"
-test-env-log = { version = "0.2", default-features = false, features = ["trace"] }
+test-log = { version = "0.2", default-features = false, features = ["trace"] }
 tracing-subscriber = "0.2"
 ureq = "2.1"
 

onnxruntime/examples/print_structure.rs

@@ -5,8 +5,7 @@ use std::error::Error;
 fn main() -> Result<(), Box<dyn Error>> {
     // provide path to .onnx model on disk
     let path = std::env::args()
-        .skip(1)
-        .next()
+        .nth(1)
         .expect("Must provide an .onnx file as the first arg");
 
     let environment = environment::Environment::builder()

onnxruntime/src/environment.rs

@@ -243,7 +243,7 @@ impl EnvBuilder {
 mod tests {
     use super::*;
     use std::sync::{RwLock, RwLockWriteGuard};
-    use test_env_log::test;
+    use test_log::test;
 
     impl G_ENV {
         fn is_initialized(&self) -> bool {
@@ -328,28 +328,25 @@ mod tests {
         let main_env = Environment::new(initial_name.clone(), LoggingLevel::Warning).unwrap();
         let main_env_ptr = main_env.env_ptr() as usize;
 
-        let children: Vec<_> = (0..10)
-            .map(|t| {
-                let initial_name_cloned = initial_name.clone();
-                std::thread::spawn(move || {
-                    let name = format!("concurrent_environment_creation: {}", t);
-                    let env = Environment::builder()
-                        .with_name(name)
-                        .with_log_level(LoggingLevel::Warning)
-                        .build()
-                        .unwrap();
-
-                    assert_eq!(env.name(), initial_name_cloned);
-                    assert_eq!(env.env_ptr() as usize, main_env_ptr);
-                })
+        let children = (0..10).map(|t| {
+            let initial_name_cloned = initial_name.clone();
+            std::thread::spawn(move || {
+                let name = format!("concurrent_environment_creation: {}", t);
+                let env = Environment::builder()
+                    .with_name(name)
+                    .with_log_level(LoggingLevel::Warning)
+                    .build()
+                    .unwrap();
+
+                assert_eq!(env.name(), initial_name_cloned);
+                assert_eq!(env.env_ptr() as usize, main_env_ptr);
             })
-            .collect();
+        });
 
         assert_eq!(main_env.name(), initial_name);
         assert_eq!(main_env.env_ptr() as usize, main_env_ptr);
 
-        let res: Vec<std::thread::Result<_>> =
-            children.into_iter().map(|child| child.join()).collect();
-        assert!(res.into_iter().all(|r| std::result::Result::is_ok(&r)));
+        let mut res = children.map(|child| child.join());
+        assert!(res.all(|r| std::result::Result::is_ok(&r)));
     }
 }

onnxruntime/src/memory.rs

@@ -52,7 +52,7 @@ impl Drop for MemoryInfo {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use test_env_log::test;
+    use test_log::test;
 
     #[test]
     fn memory_info_constructor_destructor() {

onnxruntime/src/session.rs

@@ -1,6 +1,6 @@
 //! Module containing session types
 
-use std::{ffi::CString, fmt::Debug, path::Path};
+use std::{ffi::CString, fmt::Debug, marker::PhantomData, path::Path};
 
 #[cfg(not(target_family = "windows"))]
 use std::os::unix::ffi::OsStrExt;
@@ -227,7 +227,7 @@ impl<'a> SessionBuilder<'a> {
             .collect::<Result<Vec<Output>>>()?;
 
         Ok(Session {
-            env: self.env,
+            env: PhantomData,
             session_ptr,
             allocator_ptr,
             memory_info,
@@ -283,7 +283,7 @@ impl<'a> SessionBuilder<'a> {
             .collect::<Result<Vec<Output>>>()?;
 
         Ok(Session {
-            env: self.env,
+            env: PhantomData,
             session_ptr,
             allocator_ptr,
             memory_info,
@@ -296,7 +296,7 @@ impl<'a> SessionBuilder<'a> {
 /// Type storing the session information, built from an [`Environment`](environment/struct.Environment.html)
 #[derive(Debug)]
 pub struct Session<'a> {
-    env: &'a Environment,
+    env: PhantomData<&'a Environment>,
     session_ptr: *mut sys::OrtSession,
     allocator_ptr: *mut sys::OrtAllocator,
     memory_info: MemoryInfo,

onnxruntime/src/tensor/ndarray_tensor.rs

@@ -57,7 +57,7 @@ where
 mod tests {
     use super::*;
     use ndarray::{arr1, arr2, arr3};
-    use test_env_log::test;
+    use test_log::test;
 
     #[test]
     fn softmax_1d() {

onnxruntime/src/tensor/ort_owned_tensor.rs

@@ -1,6 +1,6 @@
 //! Module containing tensor with memory owned by the ONNX Runtime
 
-use std::{fmt::Debug, ops::Deref};
+use std::{fmt::Debug, marker::PhantomData, ops::Deref};
 
 use ndarray::{Array, ArrayView};
 use tracing::debug;
@@ -31,7 +31,7 @@ where
 {
     pub(crate) tensor_ptr: *mut sys::OrtValue,
     array_view: ArrayView<'t, T, D>,
-    memory_info: &'m MemoryInfo,
+    memory_info: PhantomData<&'m MemoryInfo>,
 }
 
 impl<'t, 'm, T, D> Deref for OrtOwnedTensor<'t, 'm, T, D>
@@ -67,18 +67,18 @@ where
     D: ndarray::Dimension,
 {
     pub(crate) tensor_ptr: *mut sys::OrtValue,
-    memory_info: &'m MemoryInfo,
+    memory_info: PhantomData<&'m MemoryInfo>,
     shape: D,
 }
 
 impl<'m, D> OrtOwnedTensorExtractor<'m, D>
 where
     D: ndarray::Dimension,
 {
-    pub(crate) fn new(memory_info: &'m MemoryInfo, shape: D) -> OrtOwnedTensorExtractor<'m, D> {
+    pub(crate) fn new(_memory_info: &'m MemoryInfo, shape: D) -> OrtOwnedTensorExtractor<'m, D> {
         OrtOwnedTensorExtractor {
             tensor_ptr: std::ptr::null_mut(),
-            memory_info,
+            memory_info: PhantomData,
             shape,
         }
     }
@@ -115,7 +115,7 @@ where
         Ok(OrtOwnedTensor {
             tensor_ptr: self.tensor_ptr,
             array_view,
-            memory_info: self.memory_info,
+            memory_info: PhantomData,
         })
     }
 }

onnxruntime/src/tensor/ort_tensor.rs

@@ -1,6 +1,6 @@
 //! Module containing tensor with memory owned by Rust
 
-use std::{ffi, fmt::Debug, ops::Deref};
+use std::{ffi, fmt::Debug, marker::PhantomData, ops::Deref};
 
 use ndarray::Array;
 use tracing::{debug, error};
@@ -30,7 +30,7 @@ where
 {
     pub(crate) c_ptr: *mut sys::OrtValue,
     array: Array<T, D>,
-    memory_info: &'t MemoryInfo,
+    memory_info: PhantomData<&'t MemoryInfo>,
 }
 
 impl<'t, T, D> OrtTensor<'t, T, D>
@@ -141,7 +141,7 @@ where
         Ok(OrtTensor {
             c_ptr: tensor_ptr,
             array,
-            memory_info,
+            memory_info: PhantomData,
         })
     }
 }
@@ -198,7 +198,7 @@ mod tests {
     use crate::{AllocatorType, MemType};
     use ndarray::{arr0, arr1, arr2, arr3};
     use std::ptr;
-    use test_env_log::test;
+    use test_log::test;
 
     #[test]
     fn orttensor_from_array_0d_i32() {