Repository: eslint/eslint
File: lib/rules/require-await.js (JavaScript)

Code before:
        },

        hasSuggestions: true
    },

    create(context) {
        const sourceCode = context.sourceCode;
        let scopeInfo = null;

        /**
         * Finds the range that covers the `async` keyword.
         * @param {FunctionNode} node The function node to find the `async` keyword in.
         * @returns {[number, number] | null} The range of the `async` keyword, or null if it could not be found.
         */
        function findAsyncKeywordRange(node) {

            /*
             * If the function belongs to a method definition or
             * property, then the function's range will not include the
             * `async` keyword. We need to look at the parent instead.
             */
            const nodeWithAsyncKeyword =
                node.parent.type === "MethodDefinition" ||
                node.parent.type === "Property"
                    ? node.parent
                    : node;

            const text = context.sourceCode.getText(nodeWithAsyncKeyword);
            const match = /(^|\b)async\b/u.exec(text);

            if (match) {
                const start = nodeWithAsyncKeyword.range[0] + match.index;

                return [start, start + 5];
            }

            return null;
        }

        /**
         * Push the scope info object to the stack.
         * @returns {void}
         */
        function enterFunction() {
            scopeInfo = {
                upper: scopeInfo,
                hasAwait: false
            };
        }

        /**

Review comment (bug):
```suggestion
            const nodeWithAsyncKeyword =
                (node.parent.type === "MethodDefinition" && node.parent.value === node) ||
                (node.parent.type === "Property" && node.parent.method && node.parent.value === node)
                    ? node.parent
                    : node;
```

In this case:

```js
/* eslint require-await: "error" */

const obj = {
    async: async function foo() {
        bar();
    }
}
```

suggestion would remove the wrong `await`:

```js
/* eslint require-await: "error" */

const obj = {
    : async function foo() {
        bar();
    }
}
```

It would be good to also add a test case with his example.

Code after:
        },

        hasSuggestions: true
    },

    create(context) {
        const sourceCode = context.sourceCode;
        let scopeInfo = null;

        /**
         * Push the scope info object to the stack.
         * @returns {void}
         */
        function enterFunction() {
            scopeInfo = {
                upper: scopeInfo,
                hasAwait: false
            };
        }

        /**
         * Pop the top scope info object from the stack.
         * Also, it reports the function if needed.
         * @param {ASTNode} node The node to report.
         * @returns {void}
         */
        function exitFunction(node) {
            if (!node.generator && node.async && !scopeInfo.hasAwait && !astUtils.isEmptyFunction(node)) {

                /*
                 * If the function belongs to a method definition or
                 * property, then the function's range may not include the
                 * `async` keyword and we should look at the parent instead.
                 */
                const nodeWithAsyncKeyword =
                    (node.parent.type === "MethodDefinition" && node.parent.value === node) ||
                    (node.parent.type === "Property" && node.parent.method && node.parent.value === node)
                        ? node.parent
                        : node;

                const asyncToken = sourceCode.getFirstToken(nodeWithAsyncKeyword, token => token.value === "async");
                const asyncRange = [asyncToken.range[0], sourceCode.getTokenAfter(asyncToken, { includeComments: true }).range[0]];

                /*
                 * Removing the `async` keyword can cause parsing errors if the current
                 * statement is relying on automatic semicolon insertion. If ASI is currently
                 * being used, then we should replace the `async` keyword with a semicolon.
                 */
                const nextToken = sourceCode.getTokenAfter(asyncToken);
                const addSemiColon =
                    nextToken.type === "Punctuator" &&