eslint 6.2.2 → 6.5.1

package/lib/linter/apply-disable-directives.js

@@ -93,7 +93,7 @@ function applyDirectives(options) {
                 : "Unused eslint-disable directive (no problems were reported).",
             line: directive.unprocessedDirective.line,
             column: directive.unprocessedDirective.column,
-            severity: 2,
+            severity: options.reportUnusedDisableDirectives === "warn" ? 1 : 2,
             nodeType: null
         }));
 
@@ -114,17 +114,17 @@ function applyDirectives(options) {
  * comment for two different rules is represented as two directives).
  * @param {{ruleId: (string|null), line: number, column: number}[]} options.problems
  * A list of problems reported by rules, sorted by increasing location in the file, with one-based columns.
- * @param {boolean} options.reportUnusedDisableDirectives If `true`, adds additional problems for unused directives
+ * @param {"off" | "warn" | "error"} options.reportUnusedDisableDirectives If `"warn"` or `"error"`, adds additional problems for unused directives
  * @returns {{ruleId: (string|null), line: number, column: number}[]}
  * A list of reported problems that were not disabled by the directive comments.
  */
-module.exports = options => {
-    const blockDirectives = options.directives
+module.exports = ({ directives, problems, reportUnusedDisableDirectives = "off" }) => {
+    const blockDirectives = directives
         .filter(directive => directive.type === "disable" || directive.type === "enable")
         .map(directive => Object.assign({}, directive, { unprocessedDirective: directive }))
         .sort(compareLocations);
 
-    const lineDirectives = lodash.flatMap(options.directives, directive => {
+    const lineDirectives = lodash.flatMap(directives, directive => {
         switch (directive.type) {
             case "disable":
             case "enable":
@@ -147,10 +147,18 @@ module.exports = options => {
         }
     }).sort(compareLocations);
 
-    const blockDirectivesResult = applyDirectives({ problems: options.problems, directives: blockDirectives });
-    const lineDirectivesResult = applyDirectives({ problems: blockDirectivesResult.problems, directives: lineDirectives });
-
-    return options.reportUnusedDisableDirectives
+    const blockDirectivesResult = applyDirectives({
+        problems,
+        directives: blockDirectives,
+        reportUnusedDisableDirectives
+    });
+    const lineDirectivesResult = applyDirectives({
+        problems: blockDirectivesResult.problems,
+        directives: lineDirectives,
+        reportUnusedDisableDirectives
+    });
+
+    return reportUnusedDisableDirectives !== "off"
         ? lineDirectivesResult.problems
             .concat(blockDirectivesResult.unusedDisableDirectives)
             .concat(lineDirectivesResult.unusedDisableDirectives)

package/lib/linter/code-path-analysis/debug-helpers.js

@@ -21,7 +21,7 @@ const debug = require("debug")("eslint:code-path");
  * @returns {string} Id of the segment.
  */
 /* istanbul ignore next */
-function getId(segment) { // eslint-disable-line require-jsdoc
+function getId(segment) { // eslint-disable-line jsdoc/require-jsdoc
     return segment.id + (segment.reachable ? "" : "!");
 }
 

package/lib/linter/linter.js

@@ -54,6 +54,11 @@ const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, colum
 /** @typedef {import("../shared/types").Processor} Processor */
 /** @typedef {import("../shared/types").Rule} Rule */
 
+/**
+ * @template T
+ * @typedef {{ [P in keyof T]-?: T[P] }} Required
+ */
+
 /**
  * @typedef {Object} DisableDirective
  * @property {("disable"|"enable"|"disable-line"|"disable-next-line")} type
@@ -79,7 +84,7 @@ const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, colum
  * @property {boolean} [disableFixes] if `true` then the linter doesn't make `fix`
  *      properties into the lint result.
  * @property {string} [filename] the filename of the source code.
- * @property {boolean} [reportUnusedDisableDirectives] Adds reported errors for
+ * @property {boolean | "off" | "warn" | "error"} [reportUnusedDisableDirectives] Adds reported errors for
  *      unused `eslint-disable` directives.
  */
 
@@ -103,6 +108,12 @@ const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, colum
  *      whether fixes should be applied.
  */
 
+/**
+ * @typedef {Object} InternalOptions
+ * @property {string | null} warnInlineConfig The config name what `noInlineConfig` setting came from. If `noInlineConfig` setting didn't exist, this is null. If this is a config name, then the linter warns directive comments.
+ * @property {"off" | "warn" | "error"} reportUnusedDisableDirectives (boolean values were normalized)
+ */
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -461,13 +472,12 @@ function normalizeFilename(filename) {
     return index === -1 ? filename : parts.slice(index).join(path.sep);
 }
 
-// eslint-disable-next-line valid-jsdoc
 /**
  * Normalizes the possible options for `linter.verify` and `linter.verifyAndFix` to a
  * consistent shape.
  * @param {VerifyOptions} providedOptions Options
  * @param {ConfigData} config Config.
- * @returns {Required<VerifyOptions> & { warnInlineConfig: string|null }} Normalized options
+ * @returns {Required<VerifyOptions> & InternalOptions} Normalized options
  */
 function normalizeVerifyOptions(providedOptions, config) {
     const disableInlineConfig = config.noInlineConfig === true;
@@ -476,13 +486,22 @@ function normalizeVerifyOptions(providedOptions, config) {
         ? ` (${config.configNameOfNoInlineConfig})`
         : "";
 
+    let reportUnusedDisableDirectives = providedOptions.reportUnusedDisableDirectives;
+
+    if (typeof reportUnusedDisableDirectives === "boolean") {
+        reportUnusedDisableDirectives = reportUnusedDisableDirectives ? "error" : "off";
+    }
+    if (typeof reportUnusedDisableDirectives !== "string") {
+        reportUnusedDisableDirectives = config.reportUnusedDisableDirectives ? "warn" : "off";
+    }
+
     return {
         filename: normalizeFilename(providedOptions.filename || "<input>"),
         allowInlineConfig: !ignoreInlineConfig,
         warnInlineConfig: disableInlineConfig && !ignoreInlineConfig
             ? `your config${configNameOfNoInlineConfig}`
             : null,
-        reportUnusedDisableDirectives: Boolean(providedOptions.reportUnusedDisableDirectives),
+        reportUnusedDisableDirectives,
         disableFixes: Boolean(providedOptions.disableFixes)
     };
 }

package/lib/options.js

@@ -192,7 +192,7 @@ module.exports = optionator({
         {
             option: "report-unused-disable-directives",
             type: "Boolean",
-            default: false,
+            default: void 0,
             description: "Adds reported errors for unused eslint-disable directives"
         },
         {
@@ -224,6 +224,12 @@ module.exports = optionator({
             default: "false",
             description: "Run config initialization wizard"
         },
+        {
+            option: "env-info",
+            type: "Boolean",
+            default: "false",
+            description: "Output execution environment information"
+        },
         {
             option: "debug",
             type: "Boolean",

package/lib/rule-tester/rule-tester.js

@@ -130,7 +130,7 @@ function freezeDeeply(x) {
  */
 function sanitize(text) {
     return text.replace(
-        /[\u0000-\u001f]/gu, // eslint-disable-line no-control-regex
+        /[\u0000-\u0009|\u000b-\u001a]/gu, // eslint-disable-line no-control-regex
         c => `\\u${c.codePointAt(0).toString(16).padStart(4, "0")}`
     );
 }
@@ -177,7 +177,6 @@ class RuleTester {
     /**
      * Creates a new instance of RuleTester.
      * @param {Object} [testerConfig] Optional, extra configuration for the tester
-     * @constructor
      */
     constructor(testerConfig) {
 

package/lib/rules/accessor-pairs.js

@@ -152,7 +152,7 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "enforce getter and setter pairs in objects",
+            description: "enforce getter and setter pairs in objects and classes",
             category: "Best Practices",
             recommended: false,
             url: "https://eslint.org/docs/rules/accessor-pairs"
@@ -168,6 +168,10 @@ module.exports = {
                 setWithoutGet: {
                     type: "boolean",
                     default: true
+                },
+                enforceForClassMembers: {
+                    type: "boolean",
+                    default: false
                 }
             },
             additionalProperties: false
@@ -177,13 +181,16 @@ module.exports = {
             missingGetterInPropertyDescriptor: "Getter is not present in property descriptor.",
             missingSetterInPropertyDescriptor: "Setter is not present in property descriptor.",
             missingGetterInObjectLiteral: "Getter is not present for {{ name }}.",
-            missingSetterInObjectLiteral: "Setter is not present for {{ name }}."
+            missingSetterInObjectLiteral: "Setter is not present for {{ name }}.",
+            missingGetterInClass: "Getter is not present for class {{ name }}.",
+            missingSetterInClass: "Setter is not present for class {{ name }}."
         }
     },
     create(context) {
         const config = context.options[0] || {};
         const checkGetWithoutSet = config.getWithoutSet === true;
         const checkSetWithoutGet = config.setWithoutGet !== false;
+        const enforceForClassMembers = config.enforceForClassMembers === true;
         const sourceCode = context.getSourceCode();
 
         /**
@@ -201,6 +208,13 @@ module.exports = {
                     loc: astUtils.getFunctionHeadLoc(node.value, sourceCode),
                     data: { name: astUtils.getFunctionNameWithKind(node.value) }
                 });
+            } else if (node.type === "MethodDefinition") {
+                context.report({
+                    node,
+                    messageId: `${messageKind}InClass`,
+                    loc: astUtils.getFunctionHeadLoc(node.value, sourceCode),
+                    data: { name: astUtils.getFunctionNameWithKind(node.value) }
+                });
             } else {
                 context.report({
                     node,
@@ -313,15 +327,41 @@ module.exports = {
             }
         }
 
-        return {
-            ObjectExpression(node) {
-                if (checkSetWithoutGet || checkGetWithoutSet) {
-                    checkObjectLiteral(node);
-                    if (isPropertyDescriptor(node)) {
-                        checkPropertyDescriptor(node);
-                    }
-                }
+        /**
+         * Checks the given object expression as an object literal and as a possible property descriptor.
+         * @param {ASTNode} node `ObjectExpression` node to check.
+         * @returns {void}
+         * @private
+         */
+        function checkObjectExpression(node) {
+            checkObjectLiteral(node);
+            if (isPropertyDescriptor(node)) {
+                checkPropertyDescriptor(node);
             }
-        };
+        }
+
+        /**
+         * Checks the given class body.
+         * @param {ASTNode} node `ClassBody` node to check.
+         * @returns {void}
+         * @private
+         */
+        function checkClassBody(node) {
+            const methodDefinitions = node.body.filter(m => m.type === "MethodDefinition");
+
+            checkList(methodDefinitions.filter(m => m.static));
+            checkList(methodDefinitions.filter(m => !m.static));
+        }
+
+        const listeners = {};
+
+        if (checkSetWithoutGet || checkGetWithoutSet) {
+            listeners.ObjectExpression = checkObjectExpression;
+            if (enforceForClassMembers) {
+                listeners.ClassBody = checkClassBody;
+            }
+        }
+
+        return listeners;
     }
 };

package/lib/rules/capitalized-comments.js

@@ -59,7 +59,7 @@ const DEFAULTS = {
  * @param {string} which Either "line" or "block".
  * @returns {Object} The normalized options.
  */
-function getNormalizedOptions(rawOptions = {}, which) {
+function getNormalizedOptions(rawOptions, which) {
     return Object.assign({}, DEFAULTS, rawOptions[which] || rawOptions);
 }
 
@@ -70,7 +70,7 @@ function getNormalizedOptions(rawOptions = {}, which) {
  * @returns {Object} An object with "Line" and "Block" keys and corresponding
  * normalized options objects.
  */
-function getAllNormalizedOptions(rawOptions) {
+function getAllNormalizedOptions(rawOptions = {}) {
     return {
         Line: getNormalizedOptions(rawOptions, "line"),
         Block: getNormalizedOptions(rawOptions, "block")

package/lib/rules/computed-property-spacing.js

@@ -26,6 +26,16 @@ module.exports = {
         schema: [
             {
                 enum: ["always", "never"]
+            },
+            {
+                type: "object",
+                properties: {
+                    enforceForClassMembers: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
             }
         ],
 
@@ -41,6 +51,7 @@ module.exports = {
     create(context) {
         const sourceCode = context.getSourceCode();
         const propertyNameMustBeSpaced = context.options[0] === "always"; // default is "never"
+        const enforceForClassMembers = context.options[1] && context.options[1].enforceForClassMembers;
 
         //--------------------------------------------------------------------------
         // Helpers
@@ -178,10 +189,16 @@ module.exports = {
         // Public
         //--------------------------------------------------------------------------
 
-        return {
+        const listeners = {
             Property: checkSpacing("key"),
             MemberExpression: checkSpacing("property")
         };
 
+        if (enforceForClassMembers) {
+            listeners.MethodDefinition = checkSpacing("key");
+        }
+
+        return listeners;
+
     }
 };

package/lib/rules/default-param-last.js

@@ -0,0 +1,61 @@
+/**
+ * @fileoverview enforce default parameters to be last
+ * @author Chiawen Chen
+ */
+
+"use strict";
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "enforce default parameters to be last",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/default-param-last"
+        },
+
+        schema: [],
+
+        messages: {
+            shouldBeLast: "Default parameters should be last."
+        }
+    },
+
+    create(context) {
+
+        /**
+         * @param {ASTNode} node function node
+         * @returns {void}
+         */
+        function handleFunction(node) {
+            let hasSeenPlainParam = false;
+
+            for (let i = node.params.length - 1; i >= 0; i -= 1) {
+                const param = node.params[i];
+
+                if (
+                    param.type !== "AssignmentPattern" &&
+                    param.type !== "RestElement"
+                ) {
+                    hasSeenPlainParam = true;
+                    continue;
+                }
+
+                if (hasSeenPlainParam && param.type === "AssignmentPattern") {
+                    context.report({
+                        node: param,
+                        messageId: "shouldBeLast"
+                    });
+                }
+            }
+        }
+
+        return {
+            FunctionDeclaration: handleFunction,
+            FunctionExpression: handleFunction,
+            ArrowFunctionExpression: handleFunction
+        };
+    }
+};

package/lib/rules/eqeqeq.js

@@ -116,18 +116,6 @@ module.exports = {
             return astUtils.isNullLiteral(node.right) || astUtils.isNullLiteral(node.left);
         }
 
-        /**
-         * Gets the location (line and column) of the binary expression's operator
-         * @param {ASTNode} node The binary expression node to check
-         * @returns {Object} { line, column } location of operator
-         * @private
-         */
-        function getOperatorLocation(node) {
-            const opToken = sourceCode.getTokenAfter(node.left);
-
-            return { line: opToken.loc.start.line, column: opToken.loc.start.column };
-        }
-
         /**
          * Reports a message for this rule.
          * @param {ASTNode} node The binary expression node that was checked
@@ -136,21 +124,21 @@ module.exports = {
          * @private
          */
         function report(node, expectedOperator) {
+            const operatorToken = sourceCode.getFirstTokenBetween(
+                node.left,
+                node.right,
+                token => token.value === node.operator
+            );
+
             context.report({
                 node,
-                loc: getOperatorLocation(node),
+                loc: operatorToken.loc,
                 messageId: "unexpected",
                 data: { expectedOperator, actualOperator: node.operator },
                 fix(fixer) {
 
                     // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.
                     if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
-                        const operatorToken = sourceCode.getFirstTokenBetween(
-                            node.left,
-                            node.right,
-                            token => token.value === node.operator
-                        );
-
                         return fixer.replaceText(operatorToken, expectedOperator);
                     }
                     return null;

package/lib/rules/func-name-matching.js

@@ -118,6 +118,7 @@ module.exports = {
                 return false;
             }
             return node.type === "CallExpression" &&
+                node.callee.type === "MemberExpression" &&
                 node.callee.object.name === objName &&
                 node.callee.property.name === funcName;
         }

package/lib/rules/function-paren-newline.js

@@ -51,8 +51,8 @@ module.exports = {
             expectedBefore: "Expected newline before ')'.",
             expectedAfter: "Expected newline after '('.",
             expectedBetween: "Expected newline between arguments/params.",
-            unexpectedBefore: "Unexpected newline before '('.",
-            unexpectedAfter: "Unexpected newline after ')'."
+            unexpectedBefore: "Unexpected newline before ')'.",
+            unexpectedAfter: "Unexpected newline after '('."
         }
     },
 

package/lib/rules/indent-legacy.js

@@ -303,7 +303,7 @@ module.exports = {
          * @param {int} needed Expected indentation character count
          * @param {int} gottenSpaces Indentation space count in the actual node/code
          * @param {int} gottenTabs Indentation tab count in the actual node/code
-         * @param {Object=} loc Error line and column location
+         * @param {Object} [loc] Error line and column location
          * @param {boolean} isLastNodeCheck Is the error for last node check
          * @returns {void}
          */

package/lib/rules/indent.js

@@ -81,6 +81,9 @@ const KNOWN_NODES = new Set([
     "WhileStatement",
     "WithStatement",
     "YieldExpression",
+    "JSXFragment",
+    "JSXOpeningFragment",
+    "JSXClosingFragment",
     "JSXIdentifier",
     "JSXNamespacedName",
     "JSXMemberExpression",
@@ -1453,6 +1456,31 @@ module.exports = {
                 offsets.setDesiredOffsets(node.name.range, firstToken, 1);
             },
 
+            JSXFragment(node) {
+                const firstOpeningToken = sourceCode.getFirstToken(node.openingFragment);
+                const firstClosingToken = sourceCode.getFirstToken(node.closingFragment);
+
+                addElementListIndent(node.children, firstOpeningToken, firstClosingToken, 1);
+            },
+
+            JSXOpeningFragment(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+                const closingToken = sourceCode.getLastToken(node);
+
+                offsets.setDesiredOffsets(node.range, firstToken, 1);
+                offsets.matchOffsetOf(firstToken, closingToken);
+            },
+
+            JSXClosingFragment(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+                const slashToken = sourceCode.getLastToken(node, { skip: 1 });
+                const closingToken = sourceCode.getLastToken(node);
+                const tokenToMatch = astUtils.isTokenOnSameLine(slashToken, closingToken) ? slashToken : closingToken;
+
+                offsets.setDesiredOffsets(node.range, firstToken, 1);
+                offsets.matchOffsetOf(firstToken, tokenToMatch);
+            },
+
             JSXExpressionContainer(node) {
                 const openingCurly = sourceCode.getFirstToken(node);
                 const closingCurly = sourceCode.getLastToken(node);
@@ -1588,18 +1616,23 @@ module.exports = {
                             return;
                         }
 
-                        // If the token matches the expected expected indentation, don't report it.
-                        if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) {
-                            return;
-                        }
-
                         if (astUtils.isCommentToken(firstTokenOfLine)) {
                             const tokenBefore = precedingTokens.get(firstTokenOfLine);
                             const tokenAfter = tokenBefore ? sourceCode.getTokenAfter(tokenBefore) : sourceCode.ast.tokens[0];
-
                             const mayAlignWithBefore = tokenBefore && !hasBlankLinesBetween(tokenBefore, firstTokenOfLine);
                             const mayAlignWithAfter = tokenAfter && !hasBlankLinesBetween(firstTokenOfLine, tokenAfter);
 
+                            /*
+                             * If a comment precedes a line that begins with a semicolon token, align to that token, i.e.
+                             *
+                             * let foo
+                             * // comment
+                             * ;(async () => {})()
+                             */
+                            if (tokenAfter && astUtils.isSemicolonToken(tokenAfter) && !astUtils.isTokenOnSameLine(firstTokenOfLine, tokenAfter)) {
+                                offsets.setDesiredOffset(firstTokenOfLine, tokenAfter, 0);
+                            }
+
                             // If a comment matches the expected indentation of the token immediately before or after, don't report it.
                             if (
                                 mayAlignWithBefore && validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(tokenBefore)) ||
@@ -1609,6 +1642,11 @@ module.exports = {
                             }
                         }
 
+                        // If the token matches the expected indentation, don't report it.
+                        if (validateTokenIndent(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine))) {
+                            return;
+                        }
+
                         // Otherwise, report the token/comment.
                         report(firstTokenOfLine, offsets.getDesiredIndent(firstTokenOfLine));
                     });

package/lib/rules/index.js

@@ -37,6 +37,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "constructor-super": () => require("./constructor-super"),
     curly: () => require("./curly"),
     "default-case": () => require("./default-case"),
+    "default-param-last": () => require("./default-param-last"),
     "dot-location": () => require("./dot-location"),
     "dot-notation": () => require("./dot-notation"),
     "eol-last": () => require("./eol-last"),
@@ -131,6 +132,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "no-implicit-coercion": () => require("./no-implicit-coercion"),
     "no-implicit-globals": () => require("./no-implicit-globals"),
     "no-implied-eval": () => require("./no-implied-eval"),
+    "no-import-assign": () => require("./no-import-assign"),
     "no-inline-comments": () => require("./no-inline-comments"),
     "no-inner-declarations": () => require("./no-inner-declarations"),
     "no-invalid-regexp": () => require("./no-invalid-regexp"),
@@ -241,6 +243,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "prefer-object-spread": () => require("./prefer-object-spread"),
     "prefer-promise-reject-errors": () => require("./prefer-promise-reject-errors"),
     "prefer-reflect": () => require("./prefer-reflect"),
+    "prefer-regex-literals": () => require("./prefer-regex-literals"),
     "prefer-rest-params": () => require("./prefer-rest-params"),
     "prefer-spread": () => require("./prefer-spread"),
     "prefer-template": () => require("./prefer-template"),

package/lib/rules/new-parens.js

@@ -65,7 +65,11 @@ module.exports = {
 
                 const lastToken = sourceCode.getLastToken(node);
                 const hasLastParen = lastToken && astUtils.isClosingParenToken(lastToken);
-                const hasParens = hasLastParen && astUtils.isOpeningParenToken(sourceCode.getTokenBefore(lastToken));
+
+                // `hasParens` is true only if the new expression ends with its own parens, e.g., new new foo() does not end with its own parens
+                const hasParens = hasLastParen &&
+                    astUtils.isOpeningParenToken(sourceCode.getTokenBefore(lastToken)) &&
+                    node.callee.range[1] < node.range[1];
 
                 if (always) {
                     if (!hasParens) {

package/lib/rules/no-extra-bind.js

@@ -40,6 +40,7 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
         let scopeInfo = null;
 
         /**
@@ -71,8 +72,13 @@ module.exports = {
                         return null;
                     }
 
-                    const firstTokenToRemove = context.getSourceCode()
+                    const firstTokenToRemove = sourceCode
                         .getFirstTokenBetween(node.parent.object, node.parent.property, astUtils.isNotClosingParenToken);
+                    const lastTokenToRemove = sourceCode.getLastToken(node.parent.parent);
+
+                    if (sourceCode.commentsExistBetween(firstTokenToRemove, lastTokenToRemove)) {
+                        return null;
+                    }
 
                     return fixer.removeRange([firstTokenToRemove.range[0], node.parent.parent.range[1]]);
                 }

package/lib/rules/no-extra-boolean-cast.js

@@ -96,13 +96,23 @@ module.exports = {
                         grandparent.callee.name === "Boolean")
                 ) {
                     context.report({
-                        node,
+                        node: parent,
                         messageId: "unexpectedNegation",
                         fix: fixer => {
                             if (hasCommentsInside(parent)) {
                                 return null;
                             }
-                            return fixer.replaceText(parent, sourceCode.getText(node.argument));
+
+                            let prefix = "";
+                            const tokenBefore = sourceCode.getTokenBefore(parent);
+                            const firstReplacementToken = sourceCode.getFirstToken(node.argument);
+
+                            if (tokenBefore && tokenBefore.range[1] === parent.range[0] &&
+                                    !astUtils.canTokensBeAdjacent(tokenBefore, firstReplacementToken)) {
+                                prefix = " ";
+                            }
+
+                            return fixer.replaceText(parent, prefix + sourceCode.getText(node.argument));
                         }
                     });
                 }