eslint/lib/rules/rest-spread-spacing.js

   1 /**
   2  * @fileoverview Enforce spacing between rest and spread operators and their expressions.
   3  * @author Kai Cataldo
   4  */
   5
   6 "use strict";
   7
   8 //------------------------------------------------------------------------------
   9 // Rule Definition
  10 //------------------------------------------------------------------------------
  11
  12 module.exports = {
  13     meta: {
  14         type: "layout",
  15
  16         docs: {
  17             description: "enforce spacing between rest and spread operators and their expressions",
  18             category: "ECMAScript 6",
  19             recommended: false,
  20             url: "https://eslint.org/docs/rules/rest-spread-spacing"
  21         },
  22
  23         fixable: "whitespace",
  24
  25         schema: [
  26             {
  27                 enum: ["always", "never"]
  28             }
  29         ],
  30
  31         messages: {
  32             unexpectedWhitespace: "Unexpected whitespace after {{type}} operator.",
  33             expectedWhitespace: "Expected whitespace after {{type}} operator."
  34         }
  35     },
  36
  37     create(context) {
  38         const sourceCode = context.getSourceCode(),
  39             alwaysSpace = context.options[0] === "always";
  40
  41         //--------------------------------------------------------------------------
  42         // Helpers
  43         //--------------------------------------------------------------------------
  44
  45         /**
  46          * Checks whitespace between rest/spread operators and their expressions
  47          * @param {ASTNode} node The node to check
  48          * @returns {void}
  49          */
  50         function checkWhiteSpace(node) {
  51             const operator = sourceCode.getFirstToken(node),
  52                 nextToken = sourceCode.getTokenAfter(operator),
  53                 hasWhitespace = sourceCode.isSpaceBetweenTokens(operator, nextToken);
  54             let type;
  55
  56             switch (node.type) {
  57                 case "SpreadElement":
  58                     type = "spread";
  59                     if (node.parent.type === "ObjectExpression") {
  60                         type += " property";
  61                     }
  62                     break;
  63                 case "RestElement":
  64                     type = "rest";
  65                     if (node.parent.type === "ObjectPattern") {
  66                         type += " property";
  67                     }
  68                     break;
  69                 case "ExperimentalSpreadProperty":
  70                     type = "spread property";
  71                     break;
  72                 case "ExperimentalRestProperty":
  73                     type = "rest property";
  74                     break;
  75                 default:
  76                     return;
  77             }
  78
  79             if (alwaysSpace && !hasWhitespace) {
  80                 context.report({
  81                     node,
  82                     loc: {
  83                         line: operator.loc.end.line,
  84                         column: operator.loc.end.column
  85                     },
  86                     messageId: "expectedWhitespace",
  87                     data: {
  88                         type
  89                     },
  90                     fix(fixer) {
  91                         return fixer.replaceTextRange([operator.range[1], nextToken.range[0]], " ");
  92                     }
  93                 });
  94             } else if (!alwaysSpace && hasWhitespace) {
  95                 context.report({
  96                     node,
  97                     loc: {
  98                         line: operator.loc.end.line,
  99                         column: operator.loc.end.column
 100                     },
 101                     messageId: "unexpectedWhitespace",
 102                     data: {
 103                         type
 104                     },
 105                     fix(fixer) {
 106                         return fixer.removeRange([operator.range[1], nextToken.range[0]]);
 107                     }
 108                 });
 109             }
 110         }
 111
 112         //--------------------------------------------------------------------------
 113         // Public
 114         //--------------------------------------------------------------------------
 115
 116         return {
 117             SpreadElement: checkWhiteSpace,
 118             RestElement: checkWhiteSpace,
 119             ExperimentalSpreadProperty: checkWhiteSpace,
 120             ExperimentalRestProperty: checkWhiteSpace
 121         };
 122     }
 123 };