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

Code before:
         * @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
            };
        }

        /**
         * 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)) {
                const asyncRange = findAsyncKeywordRange(node);

                context.report({
                    node,

Review comment (refactor):
```suggestion
            const asyncToken = sourceCode.getFirstToken(nodeWithAsyncKeyword, token => token.value === "async");

            return [asyncToken.range[0], sourceCode.getTokenAfter(asyncToken).range[0]]
```

We can simplify this by using tokens, and also remove extra whitespace before the next token.

Code after:
         * @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" &&
                    (nextToken.value === "[" || nextToken.value === "(") &&
                    (nodeWithAsyncKeyword.type === "MethodDefinition" || astUtils.isStartOfExpressionStatement(nodeWithAsyncKeyword)) &&
                    astUtils.needsPrecedingSemicolon(sourceCode, nodeWithAsyncKeyword);

                context.report({
                    node,
                    loc: astUtils.getFunctionHeadLoc(node, sourceCode),
                    messageId: "missingAwait",
                    data: {
                        name: capitalizeFirstLetter(
                            astUtils.getFunctionNameWithKind(node)