tools: lint for function argument alignment

In function calls that span multiple lines, apply a custom lint rule to enforce argument alignment. With this rule, the following code will be flagged as an error by the linter because the arguments on the second line start in a different column than on the first line: myFunction(a, b, c, d); The following code will not be flagged as an error by the linter: myFunction(a, b, c, d); PR-URL: #7100 Refs: #6390 Reviewed-By: James M Snell <jasnell@gmail.com> Reviewed-By: Johan Bergström <bugs@bergstroem.nu> Reviewed-By: Brian White <mscdex@mscdex.net> Reviewed-By: Imran Iqbal <imran@imraniqbal.org> Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl> Reviewed-By: Ryan Graham <r.m.graham@gmail.com>
Trott · Apr 26, 2016 · Apr 19, 2016 · Jun 4, 2016 · 6c46eee06775939b6dfa1356187b87544602dd8d
commit 6c46eee06775939b6dfa1356187b87544602dd8d
diff --git a/.eslintrc b/.eslintrc
@@ -85,9 +85,10 @@ rules:
   prefer-const: 2
 
   # Custom rules in tools/eslint-rules
+  align-function-arguments: 2
+  align-multiline-assignment: 2
   assert-fail-single-argument: 2
   new-with-error: [2, "Error", "RangeError", "TypeError", "SyntaxError", "ReferenceError"]
-  align-multiline-assignment: 2
 
 # Global scoped method and vars
 globals:

diff --git a/tools/eslint-rules/align-function-arguments.js b/tools/eslint-rules/align-function-arguments.js
@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Align arguments in multiline function calls
+ * @author Rich Trott
+ */
+'use strict';
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+function checkArgumentAlignment(context, node) {
+
+  function isNodeFirstInLine(node, byEndLocation) {
+    const firstToken = byEndLocation === true ? context.getLastToken(node, 1) :
+      context.getTokenBefore(node);
+    const startLine = byEndLocation === true ? node.loc.end.line :
+      node.loc.start.line;
+    const endLine = firstToken ? firstToken.loc.end.line : -1;
+
+    return startLine !== endLine;
+  }
+
+  if (node.arguments.length === 0)
+    return;
+
+  var msg = '';
+  const first = node.arguments[0];
+  var currentLine = first.loc.start.line;
+  const firstColumn = first.loc.start.column;
+
+  const ignoreTypes = [
+    'ArrowFunctionExpression',
+    'CallExpression',
+    'FunctionExpression',
+    'ObjectExpression',
+    'TemplateLiteral'
+  ];
+
+  const args = node.arguments;
+
+  // For now, don't bother trying to validate potentially complicating things
+  // like closures. Different people will have very different ideas and it's
+  // probably best to implement configuration options.
+  if (args.some((node) => { return ignoreTypes.indexOf(node.type) !== -1; })) {
+    return;
+  }
+
+  if (!isNodeFirstInLine(node)) {
+    return;
+  }
+
+  args.slice(1).forEach((argument) => {
+    if (argument.loc.start.line === currentLine + 1) {
+      if (argument.loc.start.column !== firstColumn) {
+        msg = 'Function called with argument in column ' +
+              `${argument.loc.start.column}, expected in ${firstColumn}`;
+      }
+    }
+    currentLine = argument.loc.start.line;
+  });
+
+  if (msg)
+    context.report(node, msg);
+}
+
+module.exports = function(context) {
+  return {
+    'CallExpression': (node) => checkArgumentAlignment(context, node)
+  };
+};