refactor(linter/no-done-callback): remove nested if-let stmts (#13400)

Author: camc314

crates/oxc_linter/src/rules/jest/no_done_callback.rs

@@ -90,67 +90,64 @@ impl Rule for NoDoneCallback {
 
 fn run<'a>(possible_jest_node: &PossibleJestNode<'a, '_>, ctx: &LintContext<'a>) {
     let node = possible_jest_node.node;
-    if let AstKind::CallExpression(call_expr) = node.kind() {
-        if let Some(jest_fn_call) = parse_general_jest_fn_call(call_expr, possible_jest_node, ctx) {
-            let kind = jest_fn_call.kind;
-            if !matches!(
-                kind,
-                JestFnKind::General(JestGeneralFnKind::Test | JestGeneralFnKind::Hook)
-            ) {
-                return;
-            }
+    let AstKind::CallExpression(call_expr) = node.kind() else { return };
+    let Some(jest_fn_call) = parse_general_jest_fn_call(call_expr, possible_jest_node, ctx) else {
+        return;
+    };
 
-            let is_jest_each = get_node_name(&call_expr.callee).ends_with("each");
+    let kind = jest_fn_call.kind;
+    if !matches!(kind, JestFnKind::General(JestGeneralFnKind::Test | JestGeneralFnKind::Hook)) {
+        return;
+    }
 
-            if is_jest_each && !matches!(call_expr.callee, Expression::TaggedTemplateExpression(_))
-            {
-                // isJestEach but not a TaggedTemplateExpression, so this must be
-                // the `jest.each([])()` syntax which this rule doesn't support due
-                // to its complexity (see jest-community/eslint-plugin-jest#710)
-                return;
-            }
+    let is_jest_each = get_node_name(&call_expr.callee).ends_with("each");
 
-            let Some(arg) = find_argument_of_callback(call_expr, is_jest_each, kind) else {
-                return;
-            };
+    if is_jest_each && !matches!(call_expr.callee, Expression::TaggedTemplateExpression(_)) {
+        // isJestEach but not a TaggedTemplateExpression, so this must be
+        // the `jest.each([])()` syntax which this rule doesn't support due
+        // to its complexity (see jest-community/eslint-plugin-jest#710)
+        return;
+    }
 
-            let callback_arg_index = usize::from(is_jest_each);
+    let Some(arg) = find_argument_of_callback(call_expr, is_jest_each, kind) else {
+        return;
+    };
 
-            match arg {
-                Argument::FunctionExpression(func_expr) => {
-                    if func_expr.params.parameters_count() != 1 + callback_arg_index {
-                        return;
-                    }
-                    let Some(span) = get_span_of_first_parameter(&func_expr.params) else {
-                        return;
-                    };
+    let callback_arg_index = usize::from(is_jest_each);
 
-                    if func_expr.r#async {
-                        ctx.diagnostic(use_await_instead_of_callback(span));
-                        return;
-                    }
+    match arg {
+        Argument::FunctionExpression(func_expr) => {
+            if func_expr.params.parameters_count() != 1 + callback_arg_index {
+                return;
+            }
+            let Some(span) = get_span_of_first_parameter(&func_expr.params) else {
+                return;
+            };
 
-                    ctx.diagnostic(no_done_callback(span));
-                }
-                Argument::ArrowFunctionExpression(arrow_expr) => {
-                    if arrow_expr.params.parameters_count() != 1 + callback_arg_index {
-                        return;
-                    }
+            if func_expr.r#async {
+                ctx.diagnostic(use_await_instead_of_callback(span));
+                return;
+            }
 
-                    let Some(span) = get_span_of_first_parameter(&arrow_expr.params) else {
-                        return;
-                    };
+            ctx.diagnostic(no_done_callback(span));
+        }
+        Argument::ArrowFunctionExpression(arrow_expr) => {
+            if arrow_expr.params.parameters_count() != 1 + callback_arg_index {
+                return;
+            }
 
-                    if arrow_expr.r#async {
-                        ctx.diagnostic(use_await_instead_of_callback(span));
-                        return;
-                    }
+            let Some(span) = get_span_of_first_parameter(&arrow_expr.params) else {
+                return;
+            };
 
-                    ctx.diagnostic(no_done_callback(span));
-                }
-                _ => {}
+            if arrow_expr.r#async {
+                ctx.diagnostic(use_await_instead_of_callback(span));
+                return;
             }
+
+            ctx.diagnostic(no_done_callback(span));
         }
+        _ => {}
     }
 }