Fix clippy collapsible-if warnings

lovasoa · lovasoa · commit b18e138f3410 · 2026-04-17T00:20:13.000+02:00
diff --git a/src/app_config.rs b/src/app_config.rs
@@ -125,12 +125,12 @@ impl AppConfig {
                 "Database connection acquire timeout must be positive"
             ));
         }
-        if let Some(max_connections) = self.max_database_pool_connections {
-            if max_connections == 0 {
-                return Err(anyhow::anyhow!(
-                    "Maximum database pool connections must be greater than 0"
-                ));
-            }
+        if let Some(max_connections) = self.max_database_pool_connections
+            && max_connections == 0
+        {
+            return Err(anyhow::anyhow!(
+                "Maximum database pool connections must be greater than 0"
+            ));
         }
         anyhow::ensure!(self.max_pending_rows > 0, "max_pending_rows cannot be null");
 
diff --git a/src/render.rs b/src/render.rs
@@ -642,12 +642,12 @@ impl CsvBodyRenderer {
     }
 
     pub async fn handle_row(&mut self, data: &JsonValue) -> anyhow::Result<()> {
-        if self.columns.is_empty() {
-            if let Some(obj) = data.as_object() {
-                let headers: Vec<String> = obj.keys().map(String::to_owned).collect();
-                self.columns = headers;
-                self.writer.write_record(&self.columns).await?;
-            }
+        if self.columns.is_empty()
+            && let Some(obj) = data.as_object()
+        {
+            let headers: Vec<String> = obj.keys().map(String::to_owned).collect();
+            self.columns = headers;
+            self.writer.write_record(&self.columns).await?;
         }
 
         if let Some(obj) = data.as_object() {
diff --git a/src/telemetry.rs b/src/telemetry.rs
@@ -210,15 +210,15 @@ pub fn init_test_logging() {
 
 /// Shuts down the `OTel` tracer provider, flushing pending spans.
 pub fn shutdown_telemetry() {
-    if let Some(provider) = TRACER_PROVIDER.get() {
-        if let Err(e) = provider.shutdown() {
-            eprintln!("Error shutting down tracer provider: {e}");
-        }
+    if let Some(provider) = TRACER_PROVIDER.get()
+        && let Err(e) = provider.shutdown()
+    {
+        eprintln!("Error shutting down tracer provider: {e}");
     }
-    if let Some(provider) = METER_PROVIDER.get() {
-        if let Err(e) = provider.shutdown() {
-            eprintln!("Error shutting down meter provider: {e}");
-        }
+    if let Some(provider) = METER_PROVIDER.get()
+        && let Err(e) = provider.shutdown()
+    {
+        eprintln!("Error shutting down meter provider: {e}");
     }
 }
 
@@ -579,10 +579,8 @@ mod logfmt {
     }
 
     fn write_message(buf: &mut String, msg: Option<&String>, multiline_msg: bool) {
-        if !multiline_msg {
-            if let Some(msg) = msg.filter(|msg| !msg.is_empty()) {
-                write_logfmt_value(buf, "msg", msg);
-            }
+        if !multiline_msg && let Some(msg) = msg.filter(|msg| !msg.is_empty()) {
+            write_logfmt_value(buf, "msg", msg);
         }
     }
 
@@ -710,24 +708,22 @@ mod logfmt {
     {
         for span in scope? {
             let ext = span.extensions();
-            if let Some(otel_data) = ext.get::<tracing_opentelemetry::OtelData>() {
-                if let Some(trace_id) = otel_data.trace_id() {
-                    let trace_id = trace_id.to_string();
-                    if trace_id != INVALID_TRACE_ID {
-                        return Some(trace_id);
-                    }
+            if let Some(otel_data) = ext.get::<tracing_opentelemetry::OtelData>()
+                && let Some(trace_id) = otel_data.trace_id()
+            {
+                let trace_id = trace_id.to_string();
+                if trace_id != INVALID_TRACE_ID {
+                    return Some(trace_id);
                 }
             }
         }
         None
     }
 
     fn write_multiline_message(buf: &mut String, msg: Option<&String>, multiline_msg: bool) {
-        if multiline_msg {
-            if let Some(msg) = msg {
-                buf.push_str(msg);
-                buf.push('\n');
-            }
+        if multiline_msg && let Some(msg) = msg {
+            buf.push_str(msg);
+            buf.push('\n');
         }
     }
 
diff --git a/src/webserver/database/execute_queries.rs b/src/webserver/database/execute_queries.rs
@@ -681,11 +681,11 @@ fn apply_json_columns(item: &mut DbItem, json_columns: &[String]) {
                     }
                 } else if let Value::Array(array) = value {
                     for item in array {
-                        if let Value::String(json_str) = item {
-                            if let Ok(parsed_json) = serde_json::from_str(json_str) {
-                                log::trace!("Parsed JSON array item: {parsed_json}");
-                                *item = parsed_json;
-                            }
+                        if let Value::String(json_str) = item
+                            && let Ok(parsed_json) = serde_json::from_str(json_str)
+                        {
+                            log::trace!("Parsed JSON array item: {parsed_json}");
+                            *item = parsed_json;
                         }
                     }
                 }
@@ -885,12 +885,11 @@ mod tests {
         let closed_spans = layer.closed_spans.clone();
         let subscriber = tracing_subscriber::registry().with(layer);
         tracing::subscriber::with_default(subscriber, f);
-        let fields = closed_spans
+        closed_spans
             .lock()
             .unwrap()
             .pop()
-            .expect("closed span fields");
-        fields
+            .expect("closed span fields")
     }
 
     #[test]
diff --git a/src/webserver/database/sql.rs b/src/webserver/database/sql.rs
@@ -520,37 +520,35 @@ fn extract_set_variable(
         scope: None,
         hivevar: false,
     }) = stmt
-    {
-        if let ([ObjectNamePart::Identifier(ident)], [value]) =
+        && let ([ObjectNamePart::Identifier(ident)], [value]) =
             (name.as_mut_slice(), values.as_mut_slice())
-        {
-            let variable = if let Some(variable) = extract_ident_param(ident) {
-                variable
-            } else {
-                StmtParam::PostOrGet(std::mem::take(&mut ident.value))
-            };
-            let owned_expr = std::mem::replace(value, Expr::value(Value::Null));
-            let mut params_iter = params.iter().cloned();
-            if let Some(value) = expr_to_simple_select_val(&mut params_iter, &owned_expr) {
-                return Some(ParsedStatement::StaticSimpleSet { variable, value });
-            }
+    {
+        let variable = if let Some(variable) = extract_ident_param(ident) {
+            variable
+        } else {
+            StmtParam::PostOrGet(std::mem::take(&mut ident.value))
+        };
+        let owned_expr = std::mem::replace(value, Expr::value(Value::Null));
+        let mut params_iter = params.iter().cloned();
+        if let Some(value) = expr_to_simple_select_val(&mut params_iter, &owned_expr) {
+            return Some(ParsedStatement::StaticSimpleSet { variable, value });
+        }
 
-            let mut select_stmt: Statement = expr_to_statement(owned_expr);
-            let delayed_functions = extract_toplevel_functions(&mut select_stmt);
-            if let Err(err) = validate_function_calls(&select_stmt) {
-                return Some(ParsedStatement::Error(err));
-            }
-            let json_columns = extract_json_columns(&select_stmt, db_info.database_type);
-            let mut value = StmtWithParams {
-                query: select_stmt.to_string(),
-                query_position: extract_query_start(&select_stmt),
-                params: std::mem::take(params),
-                delayed_functions,
-                json_columns,
-            };
-            transform_to_positional_placeholders(&mut value, db_info.kind);
-            return Some(ParsedStatement::SetVariable { variable, value });
+        let mut select_stmt: Statement = expr_to_statement(owned_expr);
+        let delayed_functions = extract_toplevel_functions(&mut select_stmt);
+        if let Err(err) = validate_function_calls(&select_stmt) {
+            return Some(ParsedStatement::Error(err));
         }
+        let json_columns = extract_json_columns(&select_stmt, db_info.database_type);
+        let mut value = StmtWithParams {
+            query: select_stmt.to_string(),
+            query_position: extract_query_start(&select_stmt),
+            params: std::mem::take(params),
+            delayed_functions,
+            json_columns,
+        };
+        transform_to_positional_placeholders(&mut value, db_info.kind);
+        return Some(ParsedStatement::SetVariable { variable, value });
     }
     None
 }
@@ -578,10 +576,9 @@ fn extract_sqlpage_function_name(
         }),
         ObjectNamePart::Identifier(Ident { value, .. }),
     ] = func_name_parts
+        && namespace == SQLPAGE_FUNCTION_NAMESPACE
     {
-        if namespace == SQLPAGE_FUNCTION_NAMESPACE {
-            return SqlPageFunctionName::from_str(value).ok();
-        }
+        return SqlPageFunctionName::from_str(value).ok();
     }
     None
 }
@@ -610,15 +607,15 @@ fn extract_json_columns(stmt: &Statement, dbms: SupportedDatabase) -> Vec<String
 
     let mut json_columns = Vec::new();
 
-    if let Statement::Query(query) = stmt {
-        if let SetExpr::Select(select) = query.body.as_ref() {
-            for item in &select.projection {
-                if let SelectItem::ExprWithAlias { expr, alias } = item {
-                    if is_json_function(expr) {
-                        json_columns.push(alias.value.clone());
-                        log::trace!("Found JSON column: {alias}");
-                    }
-                }
+    if let Statement::Query(query) = stmt
+        && let SetExpr::Select(select) = query.body.as_ref()
+    {
+        for item in &select.projection {
+            if let SelectItem::ExprWithAlias { expr, alias } = item
+                && is_json_function(expr)
+            {
+                json_columns.push(alias.value.clone());
+                log::trace!("Found JSON column: {alias}");
             }
         }
     }
diff --git a/src/webserver/database/sql/parameter_extraction.rs b/src/webserver/database/sql/parameter_extraction.rs
@@ -120,10 +120,10 @@ impl ParameterExtractor {
 
     pub(super) fn is_own_placeholder(&self, param: &str) -> bool {
         let prefix = get_placeholder_prefix(self.db_info.kind);
-        if let Some(param) = param.strip_prefix(prefix) {
-            if let Ok(index) = param.parse::<usize>() {
-                return index <= self.parameters.len() + 1;
-            }
+        if let Some(param) = param.strip_prefix(prefix)
+            && let Ok(index) = param.parse::<usize>()
+        {
+            return index <= self.parameters.len() + 1;
         }
         false
     }
diff --git a/src/webserver/http.rs b/src/webserver/http.rs
@@ -106,20 +106,20 @@ async fn stream_response(stream: impl Stream<Item = DbItem>, mut renderer: AnyRe
             DbItem::Row(row) => renderer.handle_row(&row).await,
             DbItem::Error(e) => renderer.handle_error(&e).await,
         };
-        if let Err(e) = render_result {
-            if let Err(nested_err) = renderer.handle_error(&e).await {
-                renderer
-                    .close()
-                    .await
-                    .close_with_error(nested_err.to_string())
-                    .await;
-                log::error!(
-                    "An error occurred while trying to display an other error. \
-                    \nRoot error: {e}\n
-                    \nNested error: {nested_err}"
-                );
-                return;
-            }
+        if let Err(e) = render_result
+            && let Err(nested_err) = renderer.handle_error(&e).await
+        {
+            renderer
+                .close()
+                .await
+                .close_with_error(nested_err.to_string())
+                .await;
+            log::error!(
+                "An error occurred while trying to display an other error. \
+                \nRoot error: {e}\n
+                \nNested error: {nested_err}"
+            );
+            return;
         }
         if let Err(e) = &renderer.flush().await {
             log::error!(

Original file line number	Diff line number	Diff line change
`@@ -210,15 +210,15 @@ pub fn init_test_logging() {`
`210`	`210`
`211`	`211`	/// Shuts down the `OTel` tracer provider, flushing pending spans.
`212`	`212`	`pub fn shutdown_telemetry() {`
`213`		`- if let Some(provider) = TRACER_PROVIDER.get() {`
`214`		`- if let Err(e) = provider.shutdown() {`
`215`		`- eprintln!("Error shutting down tracer provider: {e}");`
`216`		`- }`
	`213`	`+ if let Some(provider) = TRACER_PROVIDER.get()`
	`214`	`+ && let Err(e) = provider.shutdown()`
	`215`	`+ {`
	`216`	`+ eprintln!("Error shutting down tracer provider: {e}");`
`217`	`217`	`}`
`218`		`- if let Some(provider) = METER_PROVIDER.get() {`
`219`		`- if let Err(e) = provider.shutdown() {`
`220`		`- eprintln!("Error shutting down meter provider: {e}");`
`221`		`- }`
	`218`	`+ if let Some(provider) = METER_PROVIDER.get()`
	`219`	`+ && let Err(e) = provider.shutdown()`
	`220`	`+ {`
	`221`	`+ eprintln!("Error shutting down meter provider: {e}");`
`222`	`222`	`}`
`223`	`223`	`}`
`224`	`224`
`@@ -579,10 +579,8 @@ mod logfmt {`
`579`	`579`	`}`
`580`	`580`
`581`	`581`	`fn write_message(buf: &mut String, msg: Option<&String>, multiline_msg: bool) {`
`582`		`- if !multiline_msg {`
`583`		`- if let Some(msg) = msg.filter(\|msg\| !msg.is_empty()) {`
`584`		`- write_logfmt_value(buf, "msg", msg);`
`585`		`- }`
	`582`	`+ if !multiline_msg && let Some(msg) = msg.filter(\|msg\| !msg.is_empty()) {`
	`583`	`+ write_logfmt_value(buf, "msg", msg);`
`586`	`584`	`}`
`587`	`585`	`}`
`588`	`586`
`@@ -710,24 +708,22 @@ mod logfmt {`
`710`	`708`	`{`
`711`	`709`	`for span in scope? {`
`712`	`710`	`let ext = span.extensions();`
`713`		`- if let Some(otel_data) = ext.get::<tracing_opentelemetry::OtelData>() {`
`714`		`- if let Some(trace_id) = otel_data.trace_id() {`
`715`		`- let trace_id = trace_id.to_string();`
`716`		`- if trace_id != INVALID_TRACE_ID {`
`717`		`- return Some(trace_id);`
`718`		`- }`
	`711`	`+ if let Some(otel_data) = ext.get::<tracing_opentelemetry::OtelData>()`
	`712`	`+ && let Some(trace_id) = otel_data.trace_id()`
	`713`	`+ {`
	`714`	`+ let trace_id = trace_id.to_string();`
	`715`	`+ if trace_id != INVALID_TRACE_ID {`
	`716`	`+ return Some(trace_id);`
`719`	`717`	`}`
`720`	`718`	`}`
`721`	`719`	`}`
`722`	`720`	`None`
`723`	`721`	`}`
`724`	`722`
`725`	`723`	`fn write_multiline_message(buf: &mut String, msg: Option<&String>, multiline_msg: bool) {`
`726`		`- if multiline_msg {`
`727`		`- if let Some(msg) = msg {`
`728`		`- buf.push_str(msg);`
`729`		`- buf.push('\n');`
`730`		`- }`
	`724`	`+ if multiline_msg && let Some(msg) = msg {`
	`725`	`+ buf.push_str(msg);`
	`726`	`+ buf.push('\n');`
`731`	`727`	`}`
`732`	`728`	`}`
`733`	`729`
Original file line number	Diff line number	Diff line change
`@@ -120,10 +120,10 @@ impl ParameterExtractor {`
`120`	`120`
`121`	`121`	`pub(super) fn is_own_placeholder(&self, param: &str) -> bool {`
`122`	`122`	`let prefix = get_placeholder_prefix(self.db_info.kind);`
`123`		`- if let Some(param) = param.strip_prefix(prefix) {`
`124`		`- if let Ok(index) = param.parse::<usize>() {`
`125`		`- return index <= self.parameters.len() + 1;`
`126`		`- }`
	`123`	`+ if let Some(param) = param.strip_prefix(prefix)`
	`124`	`+ && let Ok(index) = param.parse::<usize>()`
	`125`	`+ {`
	`126`	`+ return index <= self.parameters.len() + 1;`
`127`	`127`	`}`
`128`	`128`	`false`
`129`	`129`	`}`