"lint/nursery/useConsistentArrowReturn": "https://biomejs.dev/linter/rules/use-consistent-arrow-return",

pub mod use_consistent_arrow_return;

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 ,] } }

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(_)

)

const returnsObjectArrow = () => {

return { a: 1, b: 2 };

const returnsSequenceArrow = () => {

return (a, b);

const returnsAwaitArrow = async () => {

return await fetchData();

source: crates/biome_js_analyze/tests/spec_tests.rs

assertion_line: 152

expression: invalid.js

# Input

# 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()