feat: Add timeoutsErr option to no-callback-in-promise rule (#15178)

lambda47 · lambda47 · commit 7d47aaccaea7 · 2025-11-09T10:59:48.000+08:00
diff --git a/crates/oxc_linter/src/rules/promise/no_callback_in_promise.rs b/crates/oxc_linter/src/rules/promise/no_callback_in_promise.rs
@@ -6,6 +6,7 @@ use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{CompactStr, GetSpan, Span};
 use schemars::JsonSchema;
+use serde::Deserialize;
 
 use crate::{AstNode, context::LintContext, rule::Rule};
 
@@ -18,20 +19,23 @@ fn no_callback_in_promise_diagnostic(span: Span) -> OxcDiagnostic {
 #[derive(Debug, Default, Clone)]
 pub struct NoCallbackInPromise(Box<NoCallbackInPromiseConfig>);
 
-#[derive(Debug, Clone, JsonSchema)]
+#[derive(Debug, Clone, JsonSchema, Deserialize)]
 #[serde(rename_all = "camelCase", default)]
 pub struct NoCallbackInPromiseConfig {
     /// List of callback function names to check for within Promise `then` and `catch` methods.
     callbacks: Vec<CompactStr>,
     /// List of callback function names to allow within Promise `then` and `catch` methods.
     exceptions: Vec<CompactStr>,
+    /// Boolean as to whether callbacks in timeout functions like `setTimeout` will err.
+    timeouts_err: bool,
 }
 
 impl Default for NoCallbackInPromiseConfig {
     fn default() -> Self {
         Self {
             callbacks: vec!["callback".into(), "cb".into(), "done".into(), "next".into()],
             exceptions: Vec::new(),
+            timeouts_err: false,
         }
     }
 }
@@ -83,22 +87,18 @@ declare_oxc_lint!(
     config = NoCallbackInPromiseConfig,
 );
 
+const TIMEOUT_WHITELIST: [&str; 4] =
+    ["setImmediate", "setTimeout", "requestAnimationFrame", "nextTick"];
+
 impl Rule for NoCallbackInPromise {
     fn from_configuration(value: serde_json::Value) -> Self {
-        let mut default_config = NoCallbackInPromiseConfig::default();
-
-        let exceptions: Vec<String> = value
-            .get(0)
-            .and_then(|v| v.get("exceptions"))
-            .and_then(serde_json::Value::as_array)
-            .map(|v| {
-                v.iter().filter_map(serde_json::Value::as_str).map(ToString::to_string).collect()
-            })
+        let mut config: NoCallbackInPromiseConfig = value
+            .as_array()
+            .and_then(|arr| arr.first())
+            .and_then(|value| serde_json::from_value(value.clone()).ok())
             .unwrap_or_default();
-
-        default_config.callbacks.retain(|item| !exceptions.contains(&item.to_string()));
-
-        Self(Box::new(default_config))
+        config.callbacks.retain(|item| !config.exceptions.contains(&item));
+        Self(Box::new(config))
     }
 
     fn run<'a>(&self, node: &AstNode<'a>, ctx: &LintContext<'a>) {
@@ -112,20 +112,33 @@ impl Rule for NoCallbackInPromise {
             .is_none_or(|id| self.callbacks.binary_search(&id.name.as_str().into()).is_err());
 
         if is_not_callback {
+            let Some(id) = call_expr
+                .arguments
+                .first()
+                .and_then(|arg| arg.as_expression().and_then(Expression::get_identifier_reference))
+            else {
+                return;
+            };
+            let name = id.name.as_str();
+            if self.callbacks.binary_search(&name.into()).is_err() {
+                return;
+            }
             if Self::has_promise_callback(call_expr) {
-                let Some(id) = call_expr.arguments.first().and_then(|arg| {
-                    arg.as_expression().and_then(Expression::get_identifier_reference)
-                }) else {
-                    return;
-                };
-
-                let name = id.name.as_str();
-                if self.callbacks.binary_search(&name.into()).is_ok() {
-                    ctx.diagnostic(no_callback_in_promise_diagnostic(id.span));
-                }
+                ctx.diagnostic(no_callback_in_promise_diagnostic(id.span));
+                return;
+            } else if !self.timeouts_err && Self::is_inside_timeout(node) {
+                return;
+            }
+        }
+        let ancestors = ctx.nodes().ancestors(node.id());
+        for ancestor in ancestors {
+            if !self.timeouts_err && Self::is_inside_timeout(ancestor) {
+                break;
+            }
+            if Self::is_inside_promise(ancestor, ctx) {
+                ctx.diagnostic(no_callback_in_promise_diagnostic(node.span()));
+                break;
             }
-        } else if ctx.nodes().ancestors(node.id()).any(|node| Self::is_inside_promise(node, ctx)) {
-            ctx.diagnostic(no_callback_in_promise_diagnostic(node.span()));
         }
     }
 }
@@ -152,6 +165,23 @@ impl NoCallbackInPromise {
             Some("then" | "catch")
         )
     }
+
+    fn is_inside_timeout(node: &AstNode) -> bool {
+        let Some(call_expr) = node.kind().as_call_expression() else {
+            return false;
+        };
+        match &call_expr.callee {
+            Expression::Identifier(ident) => {
+                return TIMEOUT_WHITELIST.contains(&ident.name.as_str());
+            }
+            Expression::StaticMemberExpression(static_member_expr) => {
+                return TIMEOUT_WHITELIST.contains(&static_member_expr.property.name.as_str());
+            }
+            _ => {
+                return false;
+            }
+        }
+    }
 }
 
 #[test]
@@ -163,6 +193,17 @@ fn test() {
         ("doSomething(function(err) { cb(err) })", None),
         ("function thing(callback) { callback() }", None),
         ("doSomething(function(err) { callback(err) })", None),
+        ("a.then(doSomething)", None),
+        ("a.then(() => doSomething())", None),
+        ("a.then(function(err) { doSomething(err) })", None),
+        ("a.then(function(data) { doSomething(data) }, function(err) { doSomething(err) })", None),
+        ("a.catch(function(err) { doSomething(err) })", None),
+        ("whatever.then((err) => { process.nextTick(() => cb()) })", None),
+        ("whatever.then((err) => { setImmediate(() => cb()) })", None),
+        ("whatever.then((err) => setImmediate(() => cb()))", None),
+        ("whatever.then((err) => process.nextTick(() => cb()))", None),
+        ("whatever.then((err) => process.nextTick(cb))", None),
+        ("whatever.then((err) => setImmediate(cb))", None),
         ("let thing = (cb) => cb()", None),
         ("doSomething(err => cb(err))", None),
         ("a.then(() => next())", Some(serde_json::json!([{ "exceptions": ["next"] }]))),
@@ -185,6 +226,49 @@ fn test() {
         ("a.then(function(err) { callback(err) })", None),
         ("a.then(function(data) { callback(data) }, function(err) { callback(err) })", None),
         ("a.catch(function(err) { callback(err) })", None),
+        ("a.then(() => doSometing(cb))", None),
+        (
+            "function wait (callback) {
+    return Promise.resolve()
+        .then(() => {
+            setTimeout(callback);
+        });
+}",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
+        (
+            "function wait (callback) {
+    return Promise.resolve()
+        .then(() => {
+            setTimeout(() => callback());
+        });
+}",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
+        (
+            "whatever.then((err) => { process.nextTick(() => cb()) })",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
+        (
+            "whatever.then((err) => { setImmediate(() => cb()) })",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
+        (
+            "whatever.then((err) => setImmediate(() => cb()))",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
+        (
+            "whatever.then((err) => process.nextTick(() => cb()))",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
+        (
+            "whatever.then((err) => process.nextTick(cb))",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
+        (
+            "whatever.then((err) => setImmediate(cb))",
+            Some(serde_json::json!([{ "timeoutsErr": true }])),
+        ),
     ];
 
     Tester::new(NoCallbackInPromise::NAME, NoCallbackInPromise::PLUGIN, pass, fail)
diff --git a/crates/oxc_linter/src/snapshots/promise_no_callback_in_promise.snap b/crates/oxc_linter/src/snapshots/promise_no_callback_in_promise.snap
@@ -84,3 +84,70 @@ source: crates/oxc_linter/src/tester.rs
    ·                         ─────────────
    ╰────
   help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:1:14]
+ 1 │ a.then(() => doSometing(cb))
+   ·              ──────────────
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:4:13]
+ 3 │         .then(() => {
+ 4 │             setTimeout(callback);
+   ·             ────────────────────
+ 5 │         });
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:4:30]
+ 3 │         .then(() => {
+ 4 │             setTimeout(() => callback());
+   ·                              ──────────
+ 5 │         });
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:1:49]
+ 1 │ whatever.then((err) => { process.nextTick(() => cb()) })
+   ·                                                 ────
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:1:45]
+ 1 │ whatever.then((err) => { setImmediate(() => cb()) })
+   ·                                             ────
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:1:43]
+ 1 │ whatever.then((err) => setImmediate(() => cb()))
+   ·                                           ────
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:1:47]
+ 1 │ whatever.then((err) => process.nextTick(() => cb()))
+   ·                                               ────
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:1:24]
+ 1 │ whatever.then((err) => process.nextTick(cb))
+   ·                        ────────────────────
+   ╰────
+  help: Use `then` and `catch` directly
+
+  ⚠ eslint-plugin-promise(no-callback-in-promise): Avoid calling back inside of a promise
+   ╭─[no_callback_in_promise.tsx:1:24]
+ 1 │ whatever.then((err) => setImmediate(cb))
+   ·                        ────────────────
+   ╰────
+  help: Use `then` and `catch` directly
