fix(rust): let-chains

Signed-off-by: if0ne <pavel.agafonov.al@gmail.com>

Author: if0ne

rust/driver/dummy/src/lib.rs

@@ -177,12 +177,13 @@ where
 
 fn maybe_panic(fnname: impl AsRef<str>) {
     if let Some(func) = std::env::var_os("PANICDUMMY_FUNC").map(|x| x.to_string_lossy().to_string())
-        && fnname.as_ref() == func
     {
-        let message = std::env::var_os("PANICDUMMY_MESSAGE")
-            .map(|x| x.to_string_lossy().to_string())
-            .unwrap_or_else(|| format!("We panicked in {}!", fnname.as_ref()));
-        panic!("{}", message);
+        if fnname.as_ref() == func {
+            let message = std::env::var_os("PANICDUMMY_MESSAGE")
+                .map(|x| x.to_string_lossy().to_string())
+                .unwrap_or_else(|| format!("We panicked in {}!", fnname.as_ref()));
+            panic!("{}", message);
+        }
     }
 }
 

rust/driver_manager/src/search.rs

@@ -226,7 +226,7 @@ enum DriverInitFunc<'a> {
 }
 
 /// Allow using [DriverInitFunc] as a function pointer.
-impl<'a> ops::Deref for DriverInitFunc<'a> {
+impl ops::Deref for DriverInitFunc<'_> {
     type Target = FFI_AdbcDriverInitFunc;
 
     fn deref(&self) -> &Self::Target {
@@ -346,10 +346,10 @@ impl<'a> DriverLibrary<'a> {
         Ok(SearchHit::new(info.lib_path, library, info.entrypoint))
     }
 
-    pub(crate) fn derive_entrypoint<'b>(
-        entrypoint: Option<&'b [u8]>,
+    pub(crate) fn derive_entrypoint(
+        entrypoint: Option<&[u8]>,
         driver_path: impl AsRef<OsStr>,
-    ) -> Cow<'b, [u8]> {
+    ) -> Cow<'_, [u8]> {
         if let Some(entrypoint) = entrypoint {
             Cow::Borrowed(entrypoint)
         } else {
@@ -788,28 +788,30 @@ fn system_config_dir() -> Option<PathBuf> {
 
 fn get_search_paths(lvls: LoadFlags) -> Vec<PathBuf> {
     let mut result = Vec::new();
-    if lvls & LOAD_FLAG_SEARCH_ENV != 0
-        && let Some(paths) = env::var_os("ADBC_DRIVER_PATH")
-    {
-        for p in env::split_paths(&paths) {
-            result.push(p);
+    if lvls & LOAD_FLAG_SEARCH_ENV != 0 {
+        if let Some(paths) = env::var_os("ADBC_DRIVER_PATH") {
+            for p in env::split_paths(&paths) {
+                result.push(p);
+            }
         }
     }
 
-    if lvls & LOAD_FLAG_SEARCH_USER != 0
-        && let Some(path) = user_config_dir()
-        && path.exists()
-    {
-        result.push(path);
+    if lvls & LOAD_FLAG_SEARCH_USER != 0 {
+        if let Some(path) = user_config_dir() {
+            if path.exists() {
+                result.push(path);
+            }
+        }
     }
 
     // system level for windows is to search the registry keys
     #[cfg(not(windows))]
-    if lvls & LOAD_FLAG_SEARCH_SYSTEM != 0
-        && let Some(path) = system_config_dir()
-        && path.exists()
-    {
-        result.push(path);
+    if lvls & LOAD_FLAG_SEARCH_SYSTEM != 0 {
+        if let Some(path) = system_config_dir() {
+            if path.exists() {
+                result.push(path);
+            }
+        }
     }
 
     result
@@ -978,7 +980,7 @@ pub(crate) enum DriverLocator<'a> {
 /// Returns `Status::InvalidArguments` if:
 /// - The URI has no colon separator
 /// - The URI format is invalid
-pub(crate) fn parse_driver_uri<'a>(uri: &'a str) -> Result<DriverLocator<'a>> {
+pub(crate) fn parse_driver_uri(uri: &'_ str) -> Result<DriverLocator<'_>> {
     let idx = uri.find(":").ok_or(Error::with_message_and_status(
         format!("Invalid URI: {uri}"),
         Status::InvalidArguments,

rust/ffi/src/driver_exporter.rs

@@ -300,16 +300,16 @@ unsafe extern "C" fn release_ffi_driver(
     driver: *mut FFI_AdbcDriver,
     error: *mut FFI_AdbcError,
 ) -> AdbcStatusCode {
-    if let Some(driver) = driver.as_mut()
-        && driver.release.take().is_none()
-    {
-        check_err!(
-            Err(Error::with_message_and_status(
-                "Driver already released",
-                Status::InvalidState
-            )),
-            error
-        );
+    if let Some(driver) = driver.as_mut() {
+        if driver.release.take().is_none() {
+            check_err!(
+                Err(Error::with_message_and_status(
+                    "Driver already released",
+                    Status::InvalidState
+                )),
+                error
+            );
+        }
     }
     ADBC_STATUS_OK
 }

rust/ffi/src/types.rs

@@ -467,24 +467,24 @@ impl TryFrom<&FFI_AdbcError> for Error {
             details: None,
         };
 
-        if value.vendor_code == constants::ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA
-            && let Some(driver) = unsafe { value.private_driver.as_ref() }
-        {
-            let get_detail_count = driver_method!(driver, ErrorGetDetailCount);
-            let get_detail = driver_method!(driver, ErrorGetDetail);
-            let num_details = unsafe { get_detail_count(value) };
-            let details = (0..num_details)
-                .map(|i| unsafe { get_detail(value, i) })
-                .filter(|d| !d.key.is_null() && !d.value.is_null())
-                .map(|d| unsafe {
-                    // SAFETY: we assume that C gives us a valid string.
-                    let key = CStr::from_ptr(d.key).to_string_lossy().to_string();
-                    // SAFETY: we assume that C gives us valid data.
-                    let value = std::slice::from_raw_parts(d.value, d.value_length);
-                    (key, value.to_vec())
-                })
-                .collect();
-            error.details = Some(details);
+        if value.vendor_code == constants::ADBC_ERROR_VENDOR_CODE_PRIVATE_DATA {
+            if let Some(driver) = unsafe { value.private_driver.as_ref() } {
+                let get_detail_count = driver_method!(driver, ErrorGetDetailCount);
+                let get_detail = driver_method!(driver, ErrorGetDetail);
+                let num_details = unsafe { get_detail_count(value) };
+                let details = (0..num_details)
+                    .map(|i| unsafe { get_detail(value, i) })
+                    .filter(|d| !d.key.is_null() && !d.value.is_null())
+                    .map(|d| unsafe {
+                        // SAFETY: we assume that C gives us a valid string.
+                        let key = CStr::from_ptr(d.key).to_string_lossy().to_string();
+                        // SAFETY: we assume that C gives us valid data.
+                        let value = std::slice::from_raw_parts(d.value, d.value_length);
+                        (key, value.to_vec())
+                    })
+                    .collect();
+                error.details = Some(details);
+            }
         }
 
         Ok(error)