chore: Fix Clippy's collapsible_if lint

Author: Techassi

crates/stackable-telemetry/src/instrumentation/axum/injector.rs

@@ -22,10 +22,10 @@ pub struct HeaderInjector<'a>(pub(crate) &'a mut HeaderMap);
 
 impl Injector for HeaderInjector<'_> {
     fn set(&mut self, key: &str, value: String) {
-        if let Ok(header_name) = HeaderName::from_bytes(key.as_bytes()) {
-            if let Ok(header_value) = HeaderValue::from_str(&value) {
-                self.0.insert(header_name, header_value);
-            }
+        if let Ok(header_name) = HeaderName::from_bytes(key.as_bytes())
+            && let Ok(header_value) = HeaderValue::from_str(&value)
+        {
+            self.0.insert(header_name, header_value);
         }
     }
 }

crates/stackable-telemetry/src/tracing/mod.rs

@@ -570,16 +570,16 @@ impl Drop for Tracing {
             "shutting down opentelemetry OTLP providers"
         );
 
-        if let Some(tracer_provider) = &self.tracer_provider {
-            if let Err(error) = tracer_provider.shutdown() {
-                tracing::error!(%error, "unable to shutdown TracerProvider")
-            }
+        if let Some(tracer_provider) = &self.tracer_provider
+            && let Err(error) = tracer_provider.shutdown()
+        {
+            tracing::error!(%error, "unable to shutdown TracerProvider")
         }
 
-        if let Some(logger_provider) = &self.logger_provider {
-            if let Err(error) = logger_provider.shutdown() {
-                tracing::error!(%error, "unable to shutdown LoggerProvider");
-            }
+        if let Some(logger_provider) = &self.logger_provider
+            && let Err(error) = logger_provider.shutdown()
+        {
+            tracing::error!(%error, "unable to shutdown LoggerProvider");
         }
     }
 }

crates/stackable-versioned-macros/src/attrs/item/mod.rs

@@ -66,12 +66,12 @@ impl CommonItemAttributes {
     pub fn validate_versions(&self, versions: &[VersionDefinition]) -> Result<()> {
         let mut errors = Error::accumulator();
 
-        if let Some(added) = &self.added {
-            if !versions.iter().any(|v| v.inner == *added.since) {
-                errors.push(Error::custom(
+        if let Some(added) = &self.added
+            && !versions.iter().any(|v| v.inner == *added.since)
+        {
+            errors.push(Error::custom(
                     "the `added` action uses a version which is not declared via `#[versioned(version)]`",
                 ).with_span(&added.since.span()));
-            }
         }
 
         for change in &self.changes {
@@ -82,12 +82,12 @@ impl CommonItemAttributes {
             }
         }
 
-        if let Some(deprecated) = &self.deprecated {
-            if !versions.iter().any(|v| v.inner == *deprecated.since) {
-                errors.push(Error::custom(
+        if let Some(deprecated) = &self.deprecated
+            && !versions.iter().any(|v| v.inner == *deprecated.since)
+        {
+            errors.push(Error::custom(
                     "the `deprecated` action uses a version which is not declared via `#[versioned(version)]`",
                 ).with_span(&deprecated.since.span()));
-            }
         }
 
         errors.finish()
@@ -148,12 +148,11 @@ impl CommonItemAttributes {
         // version.
         // NOTE (@Techassi): Is this already covered by the code below?
         if let (Some(added_version), Some(deprecated_version)) = (added_version, deprecated_version)
+            && added_version > deprecated_version
         {
-            if added_version > deprecated_version {
-                return Err(Error::custom(format!(
+            return Err(Error::custom(format!(
                     "cannot marked as `added` in version `{added_version}` while being marked as `deprecated` in an earlier version `{deprecated_version}`"
                 )).with_span(item_idents.original()));
-            }
         }
 
         // Now, iterate over all changes and ensure that their versions are
@@ -206,11 +205,12 @@ impl CommonItemAttributes {
     /// valid.
     fn validate_added_action(&self) -> Result<()> {
         // NOTE (@Techassi): Can the path actually be empty?
-        if let Some(added) = &self.added {
-            if added.default_fn.segments.is_empty() {
-                return Err(Error::custom("`default_fn` cannot be empty")
-                    .with_span(&added.default_fn.span()));
-            }
+        if let Some(added) = &self.added
+            && added.default_fn.segments.is_empty()
+        {
+            return Err(
+                Error::custom("`default_fn` cannot be empty").with_span(&added.default_fn.span())
+            );
         }
 
         Ok(())
@@ -230,15 +230,13 @@ impl CommonItemAttributes {
             }
 
             // This ensures that `from_name` doesn't include the deprecation prefix.
-            if let Some(from_name) = change.from_name.as_ref() {
-                if from_name.starts_with(item_ident.deprecation_prefix()) {
-                    errors.push(
-                        Error::custom(
-                            "the previous name must not start with the deprecation prefix",
-                        )
+            if let Some(from_name) = change.from_name.as_ref()
+                && from_name.starts_with(item_ident.deprecation_prefix())
+            {
+                errors.push(
+                    Error::custom("the previous name must not start with the deprecation prefix")
                         .with_span(&from_name.span()),
-                    );
-                }
+                );
             }
 
             if change.from_type.is_none() {

crates/stackable-versioned-macros/src/attrs/item/variant.rs

@@ -59,13 +59,13 @@ impl VariantAttributes {
 
         // Validate names of renames
         for change in &self.common.changes {
-            if let Some(from_name) = &change.from_name {
-                if !from_name.is_case(Case::Pascal) {
-                    errors.push(
-                        Error::custom("renamed variant must use PascalCase")
-                            .with_span(&from_name.span()),
-                    )
-                }
+            if let Some(from_name) = &change.from_name
+                && !from_name.is_case(Case::Pascal)
+            {
+                errors.push(
+                    Error::custom("renamed variant must use PascalCase")
+                        .with_span(&from_name.span()),
+                )
             }
         }