New Rule Proposal: Consistent async function naming

Please describe what the rule should do:

This rule enforces that async functions are named with an Async suffix and also that any function named with an Async suffix be marked as async. It is a common practice for functions that return promises to be named with an Async suffix to indicate to the caller that they should handle a promise. (They either need to await the result, call .then, etc.) In fact, this is also the standard naming convention in .NET, which has a similar async/await pattern.

What category of rule is this? (place an “X” next to just one item)

[x] Enforces code style [ ] Warns about a potential error [ ] Suggests an alternate way of doing something [ ] Other (please specify:)

Provide 2-3 code examples that this rule will warn about:

Incorrect versions:

async function doSomething() {
    // ...
}

function doSomethingElseAsync() {
    // ...
}

Correct versions:

async function doSomethingAsync() {
    // ...
}

async function doSomethingElseAsync() {
    // ...
}

Why should this rule be included in ESLint (instead of a plugin)?

The rule inforces consistency of a very common practice (from even before the async keyword existed). It is general, library agnostic, and shouldn’t conflict with other rules.

[dtjohnson]

Seems fair that you don’t want the core to be so opinionated. @not-an-aardvark’s suggestion and @platinumazure’s example were a great start. However, there are a number of cases to cover:

async function fooAsync() {
}

function foo() {
}

const barAsync = async function () {
};

const bar = function () {
};

const bazAsync = async () => {
};

const baz = () => {
};

class Foo {
    async fooAsync() {
    }

    foo() {
    }
}

const obj = {
    async fooAsync() {
    },

    foo() {
    },

    barAsync: async function () {
    },

    bar: function () {
    },

    bazAsync: async () => {
    },

    baz: () => {
    }
};

I expanded the rule a bit to cover all of these cases and it seems to catch all of these:

{
  "no-restricted-syntax": [
    "error",
    {
      "selector": "FunctionDeclaration[async=false][id.name=/Async$/]",
      "message": "Function ending in 'Async' must be declared async"
    },
    {
      "selector": "FunctionDeclaration[async=true][id.name!=/Async$/]",
      "message": "Async function name must end in 'Async'"
    },
    {
      "selector": "MethodDefinition[value.async=false][key.name=/Async$/]",
      "message": "Method ending in 'Async' must be declared async"
    },
    {
      "selector": "MethodDefinition[value.async=true][key.name!=/Async$/]",
      "message": "Async method name must end in 'Async'"
    },
    {
      "selector": "Property[value.type=/FunctionExpression$/][value.async=false][key.name=/Async$/]",
      "message": "Function ending in 'Async' must be declared async"
    },
    {
      "selector": "Property[value.type=/FunctionExpression$/][value.async=true][key.name!=/Async$/]",
      "message": "Async function name must end in 'Async'"
    },
    {
      "selector": "VariableDeclarator[init.type=/FunctionExpression$/][init.async=false][id.name=/Async$/]",
      "message": "Function ending in 'Async' must be declared async"
    },
    {
      "selector": "VariableDeclarator[init.type=/FunctionExpression$/][init.async=true][id.name!=/Async$/]",
      "message": "Async function name must end in 'Async'"
    }
  ],
}

If you don’t feel something like this should be in the core, then at least this issue serves as an example for other folks who want to follow this async pattern. Thanks!

[ilyavolodin]

I agree with @not-an-aardvark I think this is pretty opinionated rule for the core, and should be part of a plugin (or as @platinumazure showed, should just be part of the configuration). Although I’m biased. I hate prefixes and postfixes for variable/function names.