feat(biome_js_analyze): add UseConsistentArrowReturn rule (#7245)

Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
Co-authored-by: Arend van Beelen jr. <[email protected]>
Co-authored-by: Naoki Ikeguchi <[email protected]>

Author: 4 people

.changeset/early-books-jam.md

@@ -0,0 +1,17 @@
+---
+"@biomejs/biome": patch
+---
+
+Added the new lint rule `useConsistentArrowReturn`.
+
+This rule enforces a consistent return style for arrow functions.
+
+### Invalid
+
+```js
+const f = () => {
+    return 1;
+}
+```
+
+This rule is a port of ESLint's [arrow-body-style](https://eslint.org/docs/latest/rules/arrow-body-style) rule.

crates/biome_cli/src/execute/migrate/eslint_any_rule_to_biome.rs

@@ -183,6 +183,7 @@ define_categories! {
     "lint/nursery/noVueReservedProps": "https://biomejs.dev/linter/rules/no-vue-reserved-props",
     "lint/nursery/useAnchorHref": "https://biomejs.dev/linter/rules/use-anchor-href",
     "lint/nursery/useBiomeSuppressionComment": "https://biomejs.dev/linter/rules/use-biome-suppression-comment",
+    "lint/nursery/useConsistentArrowReturn": "https://biomejs.dev/linter/rules/use-consistent-arrow-return",
     "lint/nursery/useConsistentObjectDefinition": "https://biomejs.dev/linter/rules/use-consistent-object-definition",
     "lint/nursery/useConsistentTypeDefinitions": "https://biomejs.dev/linter/rules/use-consistent-type-definitions",
     "lint/nursery/useExhaustiveSwitchCases": "https://biomejs.dev/linter/rules/use-exhaustive-switch-cases",

crates/biome_configuration/src/analyzer/linter/rules.rs

@@ -19,6 +19,7 @@ pub mod no_vue_data_object_declaration;
 pub mod no_vue_reserved_keys;
 pub mod no_vue_reserved_props;
 pub mod use_anchor_href;
+pub mod use_consistent_arrow_return;
 pub mod use_consistent_type_definitions;
 pub mod use_exhaustive_switch_cases;
 pub mod use_explicit_type;
@@ -28,4 +29,4 @@ pub mod use_qwik_classlist;
 pub mod use_react_function_components;
 pub mod use_sorted_classes;
 pub mod use_vue_multi_word_component_names;
-declare_lint_group! { pub Nursery { name : "nursery" , rules : [self :: no_floating_promises :: NoFloatingPromises , self :: no_import_cycles :: NoImportCycles , self :: no_misused_promises :: NoMisusedPromises , self :: no_next_async_client_component :: NoNextAsyncClientComponent , self :: no_non_null_asserted_optional_chain :: NoNonNullAssertedOptionalChain , self :: no_qwik_use_visible_task :: NoQwikUseVisibleTask , self :: no_secrets :: NoSecrets , self :: no_shadow :: NoShadow , self :: no_unnecessary_conditions :: NoUnnecessaryConditions , self :: no_unresolved_imports :: NoUnresolvedImports , self :: no_useless_catch_binding :: NoUselessCatchBinding , self :: no_useless_undefined :: NoUselessUndefined , self :: no_vue_data_object_declaration :: NoVueDataObjectDeclaration , self :: no_vue_reserved_keys :: NoVueReservedKeys , self :: no_vue_reserved_props :: NoVueReservedProps , self :: use_anchor_href :: UseAnchorHref , self :: use_consistent_type_definitions :: UseConsistentTypeDefinitions , self :: use_exhaustive_switch_cases :: UseExhaustiveSwitchCases , self :: use_explicit_type :: UseExplicitType , self :: use_image_size :: UseImageSize , self :: use_max_params :: UseMaxParams , self :: use_qwik_classlist :: UseQwikClasslist , self :: use_react_function_components :: UseReactFunctionComponents , self :: use_sorted_classes :: UseSortedClasses , self :: use_vue_multi_word_component_names :: UseVueMultiWordComponentNames ,] } }
+declare_lint_group! { pub Nursery { name : "nursery" , rules : [self :: no_floating_promises :: NoFloatingPromises , self :: no_import_cycles :: NoImportCycles , self :: no_misused_promises :: NoMisusedPromises , self :: no_next_async_client_component :: NoNextAsyncClientComponent , self :: no_non_null_asserted_optional_chain :: NoNonNullAssertedOptionalChain , self :: no_qwik_use_visible_task :: NoQwikUseVisibleTask , self :: no_secrets :: NoSecrets , self :: no_shadow :: NoShadow , self :: no_unnecessary_conditions :: NoUnnecessaryConditions , self :: no_unresolved_imports :: NoUnresolvedImports , self :: no_useless_catch_binding :: NoUselessCatchBinding , self :: no_useless_undefined :: NoUselessUndefined , self :: no_vue_data_object_declaration :: NoVueDataObjectDeclaration , self :: no_vue_reserved_keys :: NoVueReservedKeys , self :: no_vue_reserved_props :: NoVueReservedProps , self :: use_anchor_href :: UseAnchorHref , self :: use_consistent_arrow_return :: UseConsistentArrowReturn , self :: use_consistent_type_definitions :: UseConsistentTypeDefinitions , self :: use_exhaustive_switch_cases :: UseExhaustiveSwitchCases , self :: use_explicit_type :: UseExplicitType , self :: use_image_size :: UseImageSize , self :: use_max_params :: UseMaxParams , self :: use_qwik_classlist :: UseQwikClasslist , self :: use_react_function_components :: UseReactFunctionComponents , self :: use_sorted_classes :: UseSortedClasses , self :: use_vue_multi_word_component_names :: UseVueMultiWordComponentNames ,] } }

crates/biome_diagnostics_categories/src/categories.rs

@@ -0,0 +1,135 @@
+use crate::JsRuleAction;
+use biome_analyze::{
+    Ast, FixKind, Rule, RuleDiagnostic, RuleSource, context::RuleContext, declare_lint_rule,
+};
+use biome_console::markup;
+use biome_diagnostics::Severity;
+use biome_js_factory::make;
+use biome_js_syntax::{
+    AnyJsExpression, AnyJsFunctionBody, JsArrowFunctionExpression, JsFunctionBody,
+    JsReturnStatement,
+};
+use biome_rowan::{AstNode, AstNodeList, BatchMutationExt};
+use biome_rule_options::use_consistent_arrow_return::UseConsistentArrowReturnOptions;
+
+declare_lint_rule! {
+    /// Enforce consistent arrow function bodies.
+    ///
+    /// This rule enforces the use of arrow functions with no body block when the function body consists of a single return statement.
+    /// This rule does not report when:
+    /// - the function body contains directives (e.g. `"use strict"`), or
+    /// - the body (or its descendants) contain comments, or
+    /// - the single `return` has no argument (`return;`).
+    ///
+    /// The fix wraps expressions in parentheses when required for correctness (e.g. object literals and sequence expressions).
+    ///
+    /// ## Examples
+    ///
+    /// ### Invalid
+    ///
+    ///```js,expect_diagnostic
+    /// const bar = () => {
+    ///     return {
+    ///         bar: {
+    ///             foo: 1,
+    ///             bar: 2,
+    ///         }
+    ///     };
+    /// };
+    /// ```
+    ///
+    /// ### Valid
+    ///
+    /// ```js
+    /// const foo = () => 0;
+    /// const bar = () => { "use strict"; return 1 }
+    /// const baz = () => { /* intentional */ return x }
+    /// const qux = () => ({ a: 1 })   // already concise with parens
+    /// ```
+    ///
+    pub UseConsistentArrowReturn {
+        version: "next",
+        name: "useConsistentArrowReturn",
+        language: "js",
+        sources: &[RuleSource::Eslint("arrow-body-style").same()],
+        recommended: false,
+        severity: Severity::Warning,
+        fix_kind: FixKind::Safe,
+    }
+}
+
+impl Rule for UseConsistentArrowReturn {
+    type Query = Ast<JsArrowFunctionExpression>;
+    type State = JsFunctionBody;
+    type Signals = Option<Self::State>;
+    type Options = UseConsistentArrowReturnOptions;
+
+    fn run(ctx: &RuleContext<Self>) -> Self::Signals {
+        let arrow = ctx.query();
+        let body = JsFunctionBody::cast(arrow.body().ok()?.into_syntax())?;
+
+        if !body.directives().is_empty() || body.syntax().has_comments_descendants() {
+            return None;
+        }
+
+        if body.statements().len() == 1 {
+            let first_statement = body.statements().iter().next()?;
+            if let Some(return_statement) = JsReturnStatement::cast(first_statement.into_syntax())
+                && return_statement.argument().is_some()
+            {
+                return Some(body);
+            }
+        }
+
+        None
+    }
+
+    fn diagnostic(ctx: &RuleContext<Self>, _state: &Self::State) -> Option<RuleDiagnostic> {
+        let node = ctx.query();
+        Some(RuleDiagnostic::new(
+            rule_category!(),
+            node.range(),
+            markup! {
+                "The body of this arrow function contains a single "<Emphasis>"return"</Emphasis> " statement."
+            },
+        ))
+    }
+
+    fn action(ctx: &RuleContext<Self>, body: &Self::State) -> Option<JsRuleAction> {
+        let mut mutation = ctx.root().begin();
+
+        let return_statement = body.statements().iter().next()?;
+        let return_statement = JsReturnStatement::cast(return_statement.into_syntax())?;
+        let return_argument = return_statement.argument()?;
+
+        let new_body = if needs_parens_in_concise_body(&return_argument) {
+            AnyJsExpression::from(make::parenthesized(return_argument))
+        } else {
+            return_argument
+        };
+
+        mutation.replace_node(
+            AnyJsFunctionBody::from(body.clone()),
+            AnyJsFunctionBody::AnyJsExpression(new_body),
+        );
+
+        Some(JsRuleAction::new(
+            ctx.metadata().action_category(ctx.category(), ctx.group()),
+            ctx.metadata().applicability(),
+            markup! { "Remove the return statement." }.to_owned(),
+            mutation,
+        ))
+    }
+}
+
+fn needs_parens_in_concise_body(expr: &AnyJsExpression) -> bool {
+    use AnyJsExpression::*;
+    matches!(
+        expr,
+        JsObjectExpression(_)
+            | JsSequenceExpression(_)
+            | TsAsExpression(_)
+            | TsSatisfiesExpression(_)
+            | TsTypeAssertionExpression(_)
+    )
+}

crates/biome_js_analyze/src/lint/nursery.rs

@@ -0,0 +1,12 @@
+const returnsObjectArrow = () => {
+    return { a: 1, b: 2 };
+}
+
+const returnsSequenceArrow = () => {
+    return (a, b);
+}
+
+
+const returnsAwaitArrow = async () => {
+    return await fetchData();
+}

crates/biome_js_analyze/src/lint/nursery/use_consistent_arrow_return.rs

@@ -0,0 +1,100 @@
+---
+source: crates/biome_js_analyze/tests/spec_tests.rs
+assertion_line: 152
+expression: invalid.js
+---
+# Input
+```js
+const returnsObjectArrow = () => {
+    return { a: 1, b: 2 };
+}
+
+const returnsSequenceArrow = () => {
+    return (a, b);
+}
+
+
+const returnsAwaitArrow = async () => {
+    return await fetchData();
+}
+
+```
+
+# Diagnostics
+```
+invalid.js:1:28 lint/nursery/useConsistentArrowReturn  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The body of this arrow function contains a single return statement.
+  
+  > 1 │ const returnsObjectArrow = () => {
+      │                            ^^^^^^^
+  > 2 │     return { a: 1, b: 2 };
+  > 3 │ }
+      │ ^
+    4 │ 
+    5 │ const returnsSequenceArrow = () => {
+  
+  i Safe fix: Remove the return statement.
+  
+     1    │ - const·returnsObjectArrow·=·()·=>·{
+     2    │ - ····return·{·a:·1,·b:·2·};
+     3    │ - }
+        1 │ + const·returnsObjectArrow·=·()·=>·({·a:·1,·b:·2·})
+     4  2 │   
+     5  3 │   const returnsSequenceArrow = () => {
+  
+
+```
+
+```
+invalid.js:5:30 lint/nursery/useConsistentArrowReturn  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The body of this arrow function contains a single return statement.
+  
+    3 │ }
+    4 │ 
+  > 5 │ const returnsSequenceArrow = () => {
+      │                              ^^^^^^^
+  > 6 │     return (a, b);
+  > 7 │ }
+      │ ^
+    8 │ 
+  
+  i Safe fix: Remove the return statement.
+  
+     3  3 │   }
+     4  4 │   
+     5    │ - const·returnsSequenceArrow·=·()·=>·{
+     6    │ - ····return·(a,·b);
+     7    │ - }
+        5 │ + const·returnsSequenceArrow·=·()·=>·(a,·b)
+     8  6 │   
+     9  7 │   
+  
+
+```
+
+```
+invalid.js:10:27 lint/nursery/useConsistentArrowReturn  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The body of this arrow function contains a single return statement.
+  
+  > 10 │ const returnsAwaitArrow = async () => {
+       │                           ^^^^^^^^^^^^^
+  > 11 │     return await fetchData();
+  > 12 │ }
+       │ ^
+    13 │ 
+  
+  i Safe fix: Remove the return statement.
+  
+     8  8 │   
+     9  9 │   
+    10    │ - const·returnsAwaitArrow·=·async·()·=>·{
+    11    │ - ····return·await·fetchData();
+    12    │ - }
+       10 │ + const·returnsAwaitArrow·=·async·()·=>·await·fetchData()
+    13 11 │   
+  
+
+```

crates/biome_js_analyze/tests/specs/nursery/useConsistentArrowReturn/invalid.js

@@ -0,0 +1,64 @@
+/* should not generate diagnostics */
+const a = () => 0;
+const b = () => "hello";
+const c = (a, b) => a + b;
+const d = () => ({ a: 1 });
+
+function multiStatement() {
+    const x = 1;
+    return x;
+}
+
+const multiStatement2 = () => {
+    console.log("hello");
+};
+
+const multiStatement3 = () => {
+    let y = 2;
+    y++;
+    return y;
+}
+
+function noReturn() {
+    // I do nothing
+}
+
+function foo() {
+    return 0;
+}
+
+const noReturnArrow = () => {};
+
+function conditionalReturn(a) {
+    if (a) {
+        return 1;
+    }
+    return 0;
+}
+
+
+const withComment = () => {
+  // intentional comment
+  return 1;
+};
+
+
+const emptyReturn = () => {
+  return;
+};
+
+const withDirective = () => {
+  "use strict";
+  return 1;
+};
+
+const emptyReturnWithComment = () => {
+  return; // explicitly empty
+};
+
+const withInlineComment = () => { return 1; /* inline */ };
+const withBlockCommentBefore = () => { /* leading */ return 1; };
+const withCommentBetweenReturnAndExpr = () => { return /* comment */ 1; };
+
+const returnsSequenceArrow = () => (a, b)
+const returnsAwaitArrow = async () => await fetchData()