text: /**
   * @fileoverview Rule to flag use of comma operator
   * @author Brandon Mills
   */
  
  "use strict";
  
  //------------------------------------------------------------------------------
  // Rule Definition
  //------------------------------------------------------------------------------
  
  module.exports = function(context) {
  
      /**
       * Parts of the grammar that are required to have parens.
       */
      var parenthesized = {
          "DoWhileStatement": "test",
          "IfStatement": "test",
          "SwitchStatement": "discriminant",
          "WhileStatement": "test",
          "WithStatement": "object"
  
          // Omitting CallExpression - commas are parsed as argument separators
          // Omitting NewExpression - commas are parsed as argument separators
          // Omitting ForInStatement - parts aren't individually parenthesised
          // Omitting ForStatement - parts aren't individually parenthesised
      };
  
      /**
       * Determines whether a node is required by the grammar to be wrapped in
       * parens, e.g. the test of an if statement.
       * @param {ASTNode} node - The AST node
       * @returns {boolean} True if parens around node belong to parent node.
       */
      function requiresExtraParens(node) {
          return node.parent && parenthesized[node.parent.type] &&
                  node === node.parent[parenthesized[node.parent.type]];
      }
  
      /**
       * Check if a node is wrapped in parens.
       * @param {ASTNode} node - The AST node
       * @returns {boolean} True if the node has a paren on each side.
       */
      function isParenthesised(node) {
          var previousToken = context.getTokenBefore(node),
              nextToken = context.getTokenAfter(node);
  
          return previousToken && nextToken &&
              previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
              nextToken.value === ")" && nextToken.range[0] >= node.range[1];
      }
  
      /**
       * Check if a node is wrapped in two levels of parens.
       * @param {ASTNode} node - The AST node
       * @returns {boolean} True if two parens surround the node on each side.
       */
      function isParenthesisedTwice(node) {
          var previousToken = context.getTokenBefore(node, 1),
              nextToken = context.getTokenAfter(node, 1);
  
          return isParenthesised(node) && previousToken && nextToken &&
              previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
              nextToken.value === ")" && nextToken.range[0] >= node.range[1];
      }
  
      return {
          "SequenceExpression": function(node) {
  
              // Always allow sequences in for statement update
              if (node.parent.type === "ForStatement" &&
                      (node === node.parent.init || node === node.parent.update)) {
                  return;
              }
  
              // Wrapping a sequence in extra parens indicates intent
              if (requiresExtraParens(node)) {
                  if (isParenthesisedTwice(node)) {
                      return;
                  }
              } else {
                  if (isParenthesised(node)) {
                      return;
                  }
              }
  
              var child = context.getTokenAfter(node.expressions[0]);
  
              context.report(node, child.loc.start, "Unexpected use of comma operator.");
          }
      };
  
  };
  
  module.exports.schema = [];
  