"lint/nursery/noMisusedPromises": "https://biomejs.dev/linter/rules/no-misused-promises",

JsArrowFunctionExpression, JsAssignmentOperator, JsFunctionDeclaration, JsLanguage,

JsLogicalOperator, JsMethodClassMember, JsMethodObjectMember, JsSyntaxKind, JsSyntaxNode,

JsSyntaxToken, JsUnaryOperator,

use biome_rowan::{AstNode, AstSeparatedList, SyntaxNodeCast, TriviaPiece};

pub fn is_in_async_function(node: &JsSyntaxNode) -> bool {

node.ancestors()

.find_map(|ancestor| match ancestor.kind() {

JsSyntaxKind::JS_ARROW_FUNCTION_EXPRESSION => ancestor

.cast::<JsArrowFunctionExpression>()

.and_then(|func| func.async_token()),

JsSyntaxKind::JS_FUNCTION_DECLARATION => ancestor

.cast::<JsFunctionDeclaration>()

.and_then(|func| func.async_token()),

JsSyntaxKind::JS_METHOD_CLASS_MEMBER => ancestor

.cast::<JsMethodClassMember>()

.and_then(|method| method.async_token()),

JsSyntaxKind::JS_METHOD_OBJECT_MEMBER => ancestor

.cast::<JsMethodObjectMember>()

.and_then(|method| method.async_token()),

_ => None,

})

.is_some()

pub mod no_misused_promises;

declare_lint_group! { pub Nursery { name : "nursery" , rules : [self :: no_await_in_loop :: NoAwaitInLoop , self :: no_bitwise_operators :: NoBitwiseOperators , self :: no_constant_binary_expression :: NoConstantBinaryExpression , self :: no_destructured_props :: NoDestructuredProps , self :: no_floating_promises :: NoFloatingPromises , self :: no_global_dirname_filename :: NoGlobalDirnameFilename , self :: no_import_cycles :: NoImportCycles , self :: no_misused_promises :: NoMisusedPromises , self :: no_nested_component_definitions :: NoNestedComponentDefinitions , self :: no_noninteractive_element_interactions :: NoNoninteractiveElementInteractions , self :: no_process_global :: NoProcessGlobal , self :: no_react_prop_assign :: NoReactPropAssign , self :: no_restricted_elements :: NoRestrictedElements , self :: no_secrets :: NoSecrets , self :: no_shadow :: NoShadow , self :: no_ts_ignore :: NoTsIgnore , self :: no_unresolved_imports :: NoUnresolvedImports , self :: no_unwanted_polyfillio :: NoUnwantedPolyfillio , self :: no_useless_backref_in_regex :: NoUselessBackrefInRegex , self :: no_useless_escape_in_string :: NoUselessEscapeInString , self :: no_useless_undefined :: NoUselessUndefined , self :: use_adjacent_getter_setter :: UseAdjacentGetterSetter , self :: use_consistent_object_definition :: UseConsistentObjectDefinition , self :: use_consistent_response :: UseConsistentResponse , self :: use_exhaustive_switch_cases :: UseExhaustiveSwitchCases , self :: use_explicit_type :: UseExplicitType , self :: use_exports_last :: UseExportsLast , self :: use_for_component :: UseForComponent , self :: use_google_font_preconnect :: UseGoogleFontPreconnect , self :: use_index_of :: UseIndexOf , self :: use_iterable_callback_return :: UseIterableCallbackReturn , self :: use_json_import_attribute :: UseJsonImportAttribute , self :: use_numeric_separators :: UseNumericSeparators , self :: use_object_spread :: UseObjectSpread , self :: use_parse_int_radix :: UseParseIntRadix , self :: use_single_js_doc_asterisk :: UseSingleJsDocAsterisk , self :: use_sorted_classes :: UseSortedClasses , self :: use_symbol_description :: UseSymbolDescription , self :: use_unique_element_ids :: UseUniqueElementIds ,] } }

use biome_js_syntax::{AnyJsExpression, JsExpressionStatement, JsSyntaxKind};

use biome_rowan::{AstNode, AstSeparatedList, BatchMutationExt, TriviaPieceKind};

use crate::{JsRuleAction, ast_utils::is_in_async_function, services::typed::Typed};

if !is_in_async_function(node.syntax()) {

use biome_analyze::{

FixKind, Rule, RuleDiagnostic, RuleDomain, RuleSource, context::RuleContext, declare_lint_rule,

use biome_console::markup;

use biome_js_factory::make;

use biome_js_syntax::{AnyJsExpression, JsSyntaxKind};

use biome_rowan::{AstNode, BatchMutationExt, TriviaPieceKind};

use crate::{JsRuleAction, ast_utils::is_in_async_function, services::typed::Typed};

declare_lint_rule! {

/// Disallow Promises to be used in places where they are almost certainly a

/// mistake.

///

/// In most cases, if you assign a `Promise` somewhere a `Promise` is not

/// allowed, the TypeScript compiler will be able to catch such a mistake.

/// But there are a few places where TypeScript allows them -- they're not

/// _necessarily_ a mistake -- even though they could be considered almost

/// certainly to be one.

///

/// This rule disallows using Promises in such places.

///

/// ## Examples

///

/// ### Invalid

///

/// ```js

/// const promise = Promise.resolve('value');

/// if (promise) { /* Do something */ }

/// ```

///

/// ```js

/// const promise = Promise.resolve('value');

/// const val = promise ? 123 : 456;

/// ```

///

/// ```js

/// const promise = Promise.resolve('value');

/// [1, 2, 3].filter(() => promise);

/// ```

///

/// ```js

/// const promise = Promise.resolve('value');

/// while (promise) { /* Do something */ }

/// ```

///

/// ```js

/// const getData = () => fetch('/');

/// console.log({ foo: 42, ...getData() });

/// ```

///

/// ### Valid

///

/// ```js

/// const promise = Promise.resolve('value');

/// if (await promise) { /* Do something */ }

///

/// const val = (await promise) ? 123 : 456;

///

/// while (await promise) { /* Do something */ }

///

/// const getData = () => fetch('/');

/// console.log({ foo: 42, ...(await getData()) });

/// ```

///

pub NoMisusedPromises {

version: "next",

name: "noMisusedPromises",

language: "ts",

recommended: true,

sources: &[RuleSource::EslintTypeScript("no-misused-promises")],

fix_kind: FixKind::Unsafe,

domains: &[RuleDomain::Project],

}

pub enum NoMisusedPromisesState {

Conditional,

Spread,

impl Rule for NoMisusedPromises {

type Query = Typed<AnyJsExpression>;

type State = NoMisusedPromisesState;

type Signals = Option<Self::State>;

type Options = ();

fn run(ctx: &RuleContext<Self>) -> Self::Signals {

let expression = ctx.query();

let parent = expression.syntax().parent()?;

let state = match parent.kind() {

JsSyntaxKind::JS_CONDITIONAL_EXPRESSION => NoMisusedPromisesState::Conditional,

JsSyntaxKind::JS_DO_WHILE_STATEMENT => NoMisusedPromisesState::Conditional,

JsSyntaxKind::JS_IF_STATEMENT => NoMisusedPromisesState::Conditional,

JsSyntaxKind::JS_SPREAD => NoMisusedPromisesState::Spread,

JsSyntaxKind::JS_WHILE_STATEMENT => NoMisusedPromisesState::Conditional,

_ => return None,

};

let ty = ctx.type_for_expression(expression);

// Uncomment the following line for debugging convenience:

//let printed = format!("type of {expression:?} = {ty:?}");

let should_signal = ty.is_promise_instance()

|| matches!(state, NoMisusedPromisesState::Spread)

&& ty.has_variant(|ty| ty.is_promise_instance());

should_signal.then_some(state)

}

fn diagnostic(ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {

let node = ctx.query();

match state {

NoMisusedPromisesState::Conditional => Some(

RuleDiagnostic::new(

rule_category!(),

node.range(),

markup! {

"A Promise was found where a conditional was expected."

},

)

.note(markup! {

"A Promise is always truthy, so this is most likely a mistake."

})

.note(markup! {

"You may have intended to `await` the Promise instead."

}),

),

NoMisusedPromisesState::Spread => Some(

RuleDiagnostic::new(

rule_category!(),

node.range(),

markup! {

"A Promise was found where an iterable was expected."

},

)

.note(markup! {

"The spread syntax is used to expand an iterable, but a "

"Promise needs to be `await`-ed to take its value."

}),

),

}

}

fn action(ctx: &RuleContext<Self>, _: &Self::State) -> Option<JsRuleAction> {

let expression = ctx.query();

if !is_in_async_function(expression.syntax()) {

return None;

}

let mut mutation = ctx.root().begin();

let await_expression = AnyJsExpression::JsAwaitExpression(make::js_await_expression(

make::token(JsSyntaxKind::AWAIT_KW)

.with_trailing_trivia([(TriviaPieceKind::Whitespace, " ")]),

expression.clone().trim_leading_trivia()?,

));

mutation.replace_node(expression.clone(), await_expression);

Some(JsRuleAction::new(

ctx.metadata().action_category(ctx.category(), ctx.group()),

ctx.metadata().applicability(),

markup! { "Add await operator." }.to_owned(),

mutation,

))

}

const promise = Promise.resolve('value');

if (promise) {

// Do something

const val = promise ? 123 : 456;

[1, 2, 3].filter(() => promise);

while (promise) {

// Do something