feat(lint/useIterableCallbackReturn): add allowImplicit option

.changeset/warm-clouds-float.md

@@ -0,0 +1,5 @@
+---
+"@biomejs/biome": patch
+---
+
+Added `allowImplicit` option to [`useIterableCallbackReturn`](https://biomejs.dev/linter/rules/use-iterable-callback-return/). When set to `true`, callbacks for methods like `map` and `filter` can use `return;` to implicitly return `undefined`. This matches ESLint's `allowImplicit` option for `array-callback-return`.

crates/biome_js_analyze/src/lint/suspicious/use_iterable_callback_return.rs

@@ -85,7 +85,7 @@ declare_lint_rule! {
     ///
     /// ### `checkForEach`
     ///
-    /// **Since `v2.4.0**
+    /// **Since `v2.4.0`**
     ///
     /// Default: `true`
     ///
@@ -107,7 +107,37 @@ declare_lint_rule! {
     /// });
     /// ```
     ///
-    /// When `checkForEach` is `false` (default), the above code will not trigger any diagnostic.
+    /// When `checkForEach` is `false`, the above code will not trigger any diagnostic.
+    ///
+    /// ### `allowImplicit`
+    ///
+    /// Default: `false`
+    ///
+    /// When set to `true`, allows callbacks of methods that expect a return value
+    /// (such as `map` or `filter`) to implicitly return `undefined` using `return;`.
+    /// This is useful for patterns like mapping with early returns where some paths
+    /// intentionally return `undefined`.
+    ///
+    /// This matches ESLint's [`allowImplicit`](https://eslint.org/docs/latest/rules/array-callback-return#allowimplicit) option.
+    ///
+    /// ### Examples
+    ///
+    /// ```json,options
+    /// {
+    ///     "options": {
+    ///         "allowImplicit": true
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// ```js,use_options
+    /// [1, 2, 3].map((x) => {
+    ///     if (x > 2) return x;
+    ///     return;
+    /// });
+    /// ```
+    ///
+    /// When `allowImplicit` is `true`, the above code will not trigger any diagnostic.
     ///
     pub UseIterableCallbackReturn {
         version: "2.0.0",
@@ -180,22 +210,34 @@ impl Rule for UseIterableCallbackReturn {
 
         let returns_info = get_function_returns_info(cfg);
 
+        let allow_implicit = ctx.options().allow_implicit();
         let mut problems: Vec<RuleProblemKind> = Vec::new();
         let member_range = member_expression.member().ok()?.range();
         if method_config.return_value_required {
-            if returns_info.has_paths_without_returns {
-                if returns_info.returns_with_value.is_empty() {
+            if allow_implicit {
+                // When allowImplicit is true, `return;` is accepted.
+                // Only report if there are paths that fall through without any return at all.
+                if returns_info.has_paths_without_returns
+                    && returns_info.returns_with_value.is_empty()
+                    && returns_info.returns_without_value.is_empty()
+                {
                     problems.push(RuleProblemKind::MissingReturnWithValue);
-                } else {
-                    problems.push(RuleProblemKind::NotAllPathsReturnValue);
                 }
-            } else if !returns_info.returns_without_value.is_empty() {
-                if !returns_info.returns_with_value.is_empty() {
-                    for return_range in returns_info.returns_without_value {
-                        problems.push(RuleProblemKind::UnexpectedEmptyReturn(return_range));
+            } else {
+                if returns_info.has_paths_without_returns {
+                    if returns_info.returns_with_value.is_empty() {
+                        problems.push(RuleProblemKind::MissingReturnWithValue);
+                    } else {
+                        problems.push(RuleProblemKind::NotAllPathsReturnValue);
+                    }
+                } else if !returns_info.returns_without_value.is_empty() {
+                    if !returns_info.returns_with_value.is_empty() {
+                        for return_range in returns_info.returns_without_value {
+                            problems.push(RuleProblemKind::UnexpectedEmptyReturn(return_range));
+                        }
+                    } else {
+                        problems.push(RuleProblemKind::MissingReturnWithValue);
                     }
-                } else {
-                    problems.push(RuleProblemKind::MissingReturnWithValue);
                 }
             }
         } else {

crates/biome_rule_options/src/use_iterable_callback_return.rs

@@ -8,14 +8,27 @@ pub struct UseIterableCallbackReturnOptions {
     /// When `false` or unset, such callbacks are ignored.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub check_for_each: Option<bool>,
+
+    /// When `true`, allows callbacks in methods that require a return value
+    /// (e.g. `map`, `filter`) to implicitly return `undefined` via `return;`.
+    /// This matches ESLint's `allowImplicit` option for `array-callback-return`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub allow_implicit: Option<bool>,
 }
 
 impl UseIterableCallbackReturnOptions {
     pub const DEFAULT_CHECK_FOR_EACH: bool = true;
+    pub const DEFAULT_ALLOW_IMPLICIT: bool = false;
 
     /// Returns [`Self::check_for_each`] if it is set.
     /// Otherwise, returns [`Self::DEFAULT_CHECK_FOR_EACH`].
     pub fn check_for_each(&self) -> bool {
         self.check_for_each.unwrap_or(Self::DEFAULT_CHECK_FOR_EACH)
     }
+
+    /// Returns [`Self::allow_implicit`] if it is set.
+    /// Otherwise, returns [`Self::DEFAULT_ALLOW_IMPLICIT`].
+    pub fn allow_implicit(&self) -> bool {
+        self.allow_implicit.unwrap_or(Self::DEFAULT_ALLOW_IMPLICIT)
+    }
 }