Struct rslint_core::groups::errors::NoAwaitInLoop

pub struct NoAwaitInLoop {}

Disallow await inside of loops.

You may want to await a promise until it is fulfilled or rejected, inside of loops. In such cases, to take full advantage of concurrency, you should not await the promise in every iteration, otherwise your async operations will be executed serially. Generally it is recommended that you create all promises, then use Promise.all for them. This way your async operations will be performed concurrently.

Incorrect Code Exapmles

async function foo(xs) {
    const results = [];
    for (const x of xs) {
        // iteration does not proceed until `bar(x)` completes
        results.push(await bar(x));
    }
    return baz(results);
}

Correct Code Examples

async function foo(xs) {
    const results = [];
    for (const x of xs) {
        // push a promise to the array; it does not prevent the iteration
        results.push(bar(x));
    }
    // we wait for all the promises concurrently
    return baz(await Promise.all(results));
}

Implementations

impl NoAwaitInLoop

pub fn new() -> Self

Trait Implementations

impl Clone for NoAwaitInLoop

fn clone(&self) -> NoAwaitInLoop

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CstRule for NoAwaitInLoop

fn check_node(&self, node: &SyntaxNode, ctx: &mut RuleCtx) -> Option<()>

Check an individual node in the syntax tree. You can use the match_ast macro to make matching a node to an ast node easier. The reason this uses nodes and not a visitor is because nodes are more flexible, converting them to an AST node has zero cost and you can easily traverse surrounding nodes. Defaults to doing nothing.

fn check_token(&self, token: &SyntaxToken, ctx: &mut RuleCtx) -> Option<()>

Check an individual token in the syntax tree. Defaults to doing nothing.

fn check_root(&self, root: &SyntaxNode, ctx: &mut RuleCtx) -> Option<()>

Check the root of the tree one time. This method is guaranteed to only be called once. The root's kind will be either SCRIPT or MODULE. Defaults to doing nothing.

impl Debug for NoAwaitInLoop

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for NoAwaitInLoop

fn default() -> NoAwaitInLoop

Returns the "default value" for a type.

impl<'de> Deserialize<'de> for NoAwaitInLoop

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Rule for NoAwaitInLoop

fn name(&self) -> &'static str

A unique, kebab-case name for the rule.

fn group(&self) -> &'static str

The name of the group this rule belongs to.

fn docs(&self) -> &'static str

Optional docs for the rule, an empty string by default

impl Serialize for NoAwaitInLoop

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.