New: func-call-spacing rule (fixes #6080)

conf/eslint.json

@@ -151,6 +151,7 @@
         "dot-notation": "off",
         "eol-last": "off",
         "eqeqeq": "off",
+        "func-call-spacing": "off",
         "func-names": "off",
         "func-style": "off",
         "generator-star-spacing": "off",

docs/rules/func-call-spacing.md

@@ -0,0 +1,77 @@
+# require or disallow spacing between `function` identifiers and their invocations (func-call-spacing)
+
+(fixable) The `--fix` option on the [command line](../user-guide/command-line-interface#fix) automatically fixes problems reported by this rule.
+
+When calling a function, developers may insert optional whitespace between the function's name and the parentheses that invoke it. The following pairs of function calls are equivalent:
+
+```js
+alert('Hello');
+alert ('Hello');
+
+console.log(42);
+console.log (42);
+
+new Date();
+new Date ();
+```
+
+## Rule Details
+
+This rule requires or disallows spaces between the function name and the opening parenthesis that calls it.
+
+## options
+
+This rule has one string option:
+
+- `"never"` (default) disallows space between the function name and the opening parenthesis
+- `"always"` requires space between the function name and the opening parenthesis
+
+### never
+
+Examples of **incorrect** code for this rule with the default `"never"` option:
+
+```js
+/*eslint func-call-spacing: ["error", "never"]*/
+
+fn ();
+
+fn
+();
+```
+
+Examples of **correct** code for this rule with the default `"never"` option:
+
+```js
+/*eslint func-call-spacing: ["error", "never"]*/
+
+fn();
+```
+
+### never
+
+Examples of **incorrect** code for this rule with the `"always"` option:
+
+```js
+/*eslint func-call-spacing: ["error", "always"]*/
+
+fn();
+
+fn
+();
+```
+
+Examples of **correct** code for this rule with the `"always"` option:
+
+```js
+/*eslint func-call-spacing: ["error", "always"]*/
+
+fn ();
+```
+
+## When Not To Use It
+
+This rule can safely be turned off if your project does not care about enforcing a consistent style for spacing within function calls.
+
+## Related Rules
+
+- [no-spaced-func](no-spaced-func.md) (deprecated)

docs/rules/keyword-spacing.md

@@ -179,7 +179,7 @@ let obj = {
     foo:function() {}
 };
 
-// not conflict with `no-spaced-func`
+// not conflict with `func-call-spacing`
 class A {
     constructor() {
         super();

docs/rules/no-spaced-func.md

@@ -1,5 +1,7 @@
 # disallow spacing between `function` identifiers and their applications (no-spaced-func)
 
+This rule was **deprecated** in ESLint v3.2.0 and replaced by the [func-call-spacing](func-call-spacing.md) rule.
+
 (fixable) The `--fix` option on the [command line](../user-guide/command-line-interface#fix) automatically fixes problems reported by this rule.
 
 While it's possible to have whitespace between the name of a function and the parentheses that execute it, such patterns tend to look more like errors.

docs/rules/no-unexpected-multiline.md

@@ -66,6 +66,6 @@ Note that the patterns considered problems are **not** flagged by the [semi](sem
 
 ## Related Rules
 
+* [func-call-spacing](func-call-spacing.md)
 * [semi](semi.md)
-* [no-spaced-func](no-spaced-func.md)
 * [space-unary-ops](space-unary-ops.md)

lib/rules/func-call-spacing.js

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview Rule to control spacing within function calls
+ * @author Matt DuVall <http://www.mattduvall.com>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "require or disallow spacing between `function` identifiers and their invocations",
+            category: "Stylistic Issues",
+            recommended: false
+        },
+
+        fixable: "whitespace",
+        schema: [
+            {
+                enum: ["always", "never"]
+            }
+        ]
+    },
+
+    create: function(context) {
+
+        var never = context.options[0] !== "always",
+            sourceCode = context.getSourceCode();
+
+        /**
+         * Check if open space is present in a function name
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkSpacing(node) {
+            var lastCalleeToken = sourceCode.getLastToken(node.callee),
+                prevToken = lastCalleeToken,
+                parenToken = sourceCode.getTokenAfter(lastCalleeToken),
+                hasWhitespace;
+
+            // advances to an open parenthesis.
+            while (
+                parenToken &&
+                parenToken.range[1] < node.range[1] &&
+                parenToken.value !== "("
+            ) {
+                prevToken = parenToken;
+                parenToken = sourceCode.getTokenAfter(parenToken);
+            }
+
+            // Parens in NewExpression are optional
+            if (!(parenToken && parenToken.range[1] < node.range[1])) {
+                return;
+            }
+
+            hasWhitespace = sourceCode.isSpaceBetweenTokens(prevToken, parenToken);
+
+            if (never && hasWhitespace) {
+                context.report({
+                    node: node,
+                    loc: lastCalleeToken.loc.start,
+                    message: "Unexpected space between function name and paren.",
+                    fix: function(fixer) {
+                        return fixer.removeRange([prevToken.range[1], parenToken.range[0]]);
+                    }
+                });
+            } else if (!never && !hasWhitespace) {
+                context.report({
+                    node: node,
+                    loc: lastCalleeToken.loc.start,
+                    message: "Missing space between function name and paren.",
+                    fix: function(fixer) {
+                        return fixer.insertTextBefore(parenToken, " ");
+                    }
+                });
+            }
+        }
+
+        return {
+            CallExpression: checkSpacing,
+            NewExpression: checkSpacing
+        };
+
+    }
+};

lib/rules/no-spaced-func.js

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to check that spaced function application
  * @author Matt DuVall <http://www.mattduvall.com>
+ * @deprecated in ESLint v3.2.0
  */
 
 "use strict";

packages/eslint-config-eslint/default.yml

@@ -19,6 +19,7 @@ rules:
     dot-notation: ["error", { allowKeywords: true }]
     eol-last: "error"
     eqeqeq: "error"
+    func-call-spacing: "error"
     func-style: ["error", "declaration"]
     generator-star-spacing: "error"
     guard-for-in: "error"
@@ -71,7 +72,6 @@ rules:
     no-sequences: "error"
     no-shadow: "error"
     no-shadow-restricted-names: "error"
-    no-spaced-func: "error"
     no-trailing-spaces: "error"
     no-undef: "error"
     no-undef-init: "error"