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

Code before:
    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]} The range of the `async` keyword.
         */
        function findAsyncKeywordRange(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");


            return [asyncToken.range[0], sourceCode.getTokenAfter(asyncToken).range[0]];
        }

        /**
         * 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 (suggestion):
Shouldn't we only remove `async` and leave space alone? Currently we will remove comments

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

                context.report({