New: Rest Parameter (refs: #10)

README.md

@@ -89,6 +89,9 @@ var ast = espree.parse(code, {
         // enable parsing of default parameters
         defaultParams: false,
 
+        // enable parsing of rest parameters
+        restParams: true,
+
         // enable parsing of for-of statement
         forOf: true,
 

espree.js

@@ -553,7 +553,7 @@ function scanPunctuator() {
     }
 
     // The ... operator only valid in JSX mode for now
-    if (extra.ecmaFeatures.jsx && state.inJSXSpreadAttribute) {
+    if (extra.ecmaFeatures.restParams || (extra.ecmaFeatures.jsx && state.inJSXSpreadAttribute)) {
         if (ch1 === "." && ch2 === "." && ch3 === ".") {
             index += 3;
             return {
@@ -2860,6 +2860,15 @@ function parseArguments() {
     return args;
 }
 
+function parseSpreadOrAssignmentExpression() {
+    if (match("...")) {
+        var marker = markerCreate();
+        lex();
+        return markerApply(marker, astNodeFactory.createSpreadElement(parseAssignmentExpression()));
+    }
+    return parseAssignmentExpression();
+}
+
 function parseNonComputedProperty() {
     var token,
         marker = markerCreate();
@@ -3218,6 +3227,13 @@ function reinterpretAsCoverFormalsList(expressions) {
             reinterpretAsDestructuredParameter(options, param);
             params.push(param);
             defaults.push(null);
+        } else if (param.type === astNodeTypes.SpreadElement) {
+            assert(i === len - 1, "It is guaranteed that SpreadElement is last element by parseExpression");
+            if (param.argument.type !== astNodeTypes.Identifier) {
+                throwError({}, Messages.InvalidLHSInFormalsList);
+            }
+            reinterpretAsDestructuredParameter(options, param.argument);
+            rest = param.argument;
         } else if (param.type === astNodeTypes.AssignmentExpression) {
             params.push(param.left);
             defaults.push(param.right);
@@ -3266,7 +3282,13 @@ function parseArrowFunctionExpression(options, marker) {
     }
 
     strict = previousStrict;
-    return markerApply(marker, astNodeFactory.createArrowFunctionExpression(options.params, options.defaults, body, body.type !== astNodeTypes.BlockStatement));
+    return markerApply(marker, astNodeFactory.createArrowFunctionExpression(
+        options.params,
+        options.defaults,
+        body,
+        options.rest,
+        body.type !== astNodeTypes.BlockStatement
+    ));
 }
 
 // 11.13 Assignment Operators
@@ -3323,7 +3345,7 @@ function reinterpretAsDestructuredParameter(options, expr) {
         allowDestructuring = extra.ecmaFeatures.destructuring;
 
     if (!allowDestructuring) {
-         throwUnexpected(lex());
+        throwUnexpected(lex());
     }
 
     if (expr.type === astNodeTypes.ObjectExpression) {
@@ -3374,7 +3396,7 @@ function parseAssignmentExpression() {
 
     if (match("(")) {
         token = lookahead2();
-        if (token.value === ")" && token.type === Token.Punctuator) {
+        if ((token.value === ")" && token.type === Token.Punctuator) || token.value === "...") {
             params = parseParams();
             if (!match("=>")) {
                 throwUnexpected(lex());
@@ -3435,26 +3457,37 @@ function parseAssignmentExpression() {
 // 11.14 Comma Operator
 
 function parseExpression() {
-    var expr,
-        marker = markerCreate();
-
-    expr = parseAssignmentExpression();
+    var marker = markerCreate(),
+        expr = parseAssignmentExpression(),
+        expressions = [ expr ],
+        sequence, spreadFound;
 
     if (match(",")) {
-        expr = astNodeFactory.createSequenceExpression([ expr ]);
-
         while (index < length) {
             if (!match(",")) {
                 break;
             }
             lex();
-            expr.expressions.push(parseAssignmentExpression());
+            expr = parseSpreadOrAssignmentExpression();
+            expressions.push(expr);
+
+            if (expr.type === astNodeTypes.SpreadElement) {
+                spreadFound = true;
+                if (!match(")")) {
+                    throwError({}, Messages.ElementAfterSpreadElement);
+                }
+                break;
+            }
         }
 
-        markerApply(marker, expr);
+        sequence = markerApply(marker, astNodeFactory.createSequenceExpression(expressions));
     }
 
-    return expr;
+    if (spreadFound && lookahead2().value !== "=>") {
+        throwError({}, Messages.IllegalSpread);
+    }
+
+    return sequence || expr;
 }
 
 // 12.1 Block
@@ -4265,11 +4298,19 @@ function validateParam(options, param, name) {
 }
 
 function parseParam(options) {
-    var token, param, def,
+    var token, rest, param, def,
+        allowRestParams = extra.ecmaFeatures.restParams,
         allowDestructuring = extra.ecmaFeatures.destructuring,
         allowDefaultParams = extra.ecmaFeatures.defaultParams;
 
     token = lookahead;
+    if (token.value === "...") {
+        if (!allowRestParams) {
+            throwUnexpected(lookahead);
+        }
+        token = lex();
+        rest = true;
+    }
 
     if (match("[")) {
         if (!allowDestructuring) {
@@ -4278,6 +4319,9 @@ function parseParam(options) {
         param = parseArrayInitialiser();
         reinterpretAsDestructuredParameter(options, param);
     } else if (match("{")) {
+        if (rest) {
+            throwError({}, Messages.ObjectPatternAsRestParameter);
+        }
         if (!allowDestructuring) {
             throwUnexpected(lookahead);
         }
@@ -4289,6 +4333,9 @@ function parseParam(options) {
     }
 
     if (match("=")) {
+        if (rest) {
+            throwErrorTolerant(lookahead, Messages.DefaultRestParameter);
+        }
         if (!allowDefaultParams) {
             throwUnexpected(lookahead);
         }
@@ -4297,6 +4344,14 @@ function parseParam(options) {
         ++options.defaultCount;
     }
 
+    if (rest) {
+        if (!match(")")) {
+            throwError({}, Messages.ParameterAfterRestParameter);
+        }
+        options.rest = param;
+        return false;
+    }
+
     options.params.push(param);
     options.defaults.push(def ? def : null); // TODO: determine if null or undefined (see: #55)
 

lib/ast-node-factory.js

@@ -56,19 +56,20 @@ module.exports = {
      * @param {ASTNode} params The function arguments
      * @param {ASTNode} defaults Any default arguments
      * @param {ASTNode} body The function body
+     * @param {ASTNode} rest The rest parameter
      * @param {boolean} expression True if the arrow function is created via an expression.
      *      Always false for declarations, but kept here to be in sync with
      *      FunctionExpression objects.
      * @returns {ASTNode} An ASTNode representing the entire arrow function expression
      */
-    createArrowFunctionExpression: function (params, defaults, body, expression) {
+    createArrowFunctionExpression: function (params, defaults, body, rest, expression) {
         return {
             type: astNodeTypes.ArrowFunctionExpression,
             id: null,
             params: params,
             defaults: defaults,
             body: body,
-            rest: null,
+            rest: rest,
             generator: false,
             expression: expression
         };
@@ -442,6 +443,18 @@ module.exports = {
         };
     },
 
+    /**
+     * Create an ASTNode representation of a spread element
+     * @param {ASTNode} argument The array being spread
+     * @returns {ASTNode} An ASTNode representing a spread element
+     */
+    createSpreadElement: function (argument) {
+        return {
+            type: astNodeTypes.SpreadElement,
+            argument: argument
+        };
+    },
+
     /**
      * Create an ASTNode tagged template expression
      * @param {ASTNode} tag The tag expression

lib/ast-node-types.js

@@ -71,6 +71,7 @@ module.exports = {
     Property: "Property",
     ReturnStatement: "ReturnStatement",
     SequenceExpression: "SequenceExpression",
+    SpreadElement: "SpreadElement",
     SwitchCase: "SwitchCase",
     SwitchStatement: "SwitchStatement",
     TaggedTemplateExpression: "TaggedTemplateExpression",

lib/features.js

@@ -70,6 +70,9 @@ module.exports = {
     // enable parsing of default parameters
     defaultParams: false,
 
+    // enable parsing of rest parameters
+    restParams: false,
+
     // enable parsing of for-of statements
     forOf: false,
 

lib/messages.js

@@ -62,11 +62,17 @@ module.exports = {
     IllegalBreak: "Illegal break statement",
     IllegalReturn: "Illegal return statement",
     IllegalYield: "Illegal yield expression",
+    IllegalSpread: "Illegal spread element",
     StrictModeWith: "Strict mode code may not include a with statement",
     StrictCatchVariable: "Catch variable may not be eval or arguments in strict mode",
     StrictVarName: "Variable name may not be eval or arguments in strict mode",
     StrictParamName: "Parameter name eval or arguments is not allowed in strict mode",
     StrictParamDupe: "Strict mode function may not have duplicate parameter names",
+    ParameterAfterRestParameter: "Rest parameter must be final parameter of an argument list",
+    DefaultRestParameter: "Rest parameter can not have a default value",
+    ElementAfterSpreadElement: "Spread must be the final element of an element list",
+    ObjectPatternAsRestParameter: "Invalid rest parameter",
+    ObjectPatternAsSpread: "Invalid spread argument",
     StrictFunctionName: "Function name may not be eval or arguments in strict mode",
     StrictOctalLiteral: "Octal literals are not allowed in strict mode.",
     StrictDelete: "Delete of an unqualified identifier in strict mode.",

tests/fixtures/ast/API.json

@@ -182,6 +182,7 @@
             "Property": "Property",
             "ReturnStatement": "ReturnStatement",
             "SequenceExpression": "SequenceExpression",
+            "SpreadElement": "SpreadElement",
             "SwitchCase": "SwitchCase",
             "SwitchStatement": "SwitchStatement",
             "TaggedTemplateExpression": "TaggedTemplateExpression",

tests/fixtures/ecma-features-mix/restParams-and-arrowFunctions/arrow-rest-multi.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+    arrowFunctions: true,
+    restParams: true,
+    destructuring: true
+};

tests/fixtures/ecma-features-mix/restParams-and-arrowFunctions/arrow-rest-multi.result.js

@@ -0,0 +1,113 @@
+module.exports = {
+    "type": "Program",
+    "body": [
+        {
+            "type": "ExpressionStatement",
+            "expression": {
+                "type": "ArrowFunctionExpression",
+                "id": null,
+                "params": [
+                    {
+                        "type": "Identifier",
+                        "name": "a",
+                        "range": [
+                            1,
+                            2
+                        ],
+                        "loc": {
+                            "start": {
+                                "line": 1,
+                                "column": 1
+                            },
+                            "end": {
+                                "line": 1,
+                                "column": 2
+                            }
+                        }
+                    }
+                ],
+                "defaults": [],
+                "body": {
+                    "type": "BlockStatement",
+                    "body": [],
+                    "range": [
+                        13,
+                        15
+                    ],
+                    "loc": {
+                        "start": {
+                            "line": 1,
+                            "column": 13
+                        },
+                        "end": {
+                            "line": 1,
+                            "column": 15
+                        }
+                    }
+                },
+                "rest": {
+                    "type": "Identifier",
+                    "name": "b",
+                    "range": [
+                        7,
+                        8
+                    ],
+                    "loc": {
+                        "start": {
+                            "line": 1,
+                            "column": 7
+                        },
+                        "end": {
+                            "line": 1,
+                            "column": 8
+                        }
+                    }
+                },
+                "generator": false,
+                "expression": false,
+                "range": [
+                    0,
+                    15
+                ],
+                "loc": {
+                    "start": {
+                        "line": 1,
+                        "column": 0
+                    },
+                    "end": {
+                        "line": 1,
+                        "column": 15
+                    }
+                }
+            },
+            "range": [
+                0,
+                16
+            ],
+            "loc": {
+                "start": {
+                    "line": 1,
+                    "column": 0
+                },
+                "end": {
+                    "line": 1,
+                    "column": 16
+                }
+            }
+        }
+    ],
+    "range": [
+        0,
+        16
+    ],
+    "loc": {
+        "start": {
+            "line": 1,
+            "column": 0
+        },
+        "end": {
+            "line": 1,
+            "column": 16
+        }
+    }
+}

tests/fixtures/ecma-features-mix/restParams-and-arrowFunctions/arrow-rest-multi.src.js

@@ -0,0 +1 @@
+(a, ...b) => {};

tests/fixtures/ecma-features-mix/restParams-and-arrowFunctions/arrow-rest.config.js

@@ -0,0 +1,4 @@
+module.exports = {
+    arrowFunctions: true,
+    restParams: true
+};