From ebc7e7e0e326cd501d959b7aa8f58f6a8dbfb36e Mon Sep 17 00:00:00 2001
From: Anders Hejlsberg <andersh@microsoft.com>
Date: Wed, 10 Dec 2014 06:45:01 -0800
Subject: [PATCH] Parsing of spread element expressions

---
 src/compiler/checker.ts |  2 ++
 src/compiler/parser.ts  | 12 +++++++++++-
 src/compiler/types.ts   |  7 ++++++-
 3 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8c383368df2..ce58b6d27c7 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4553,6 +4553,7 @@ module ts {
                     case SyntaxKind.VoidExpression:
                     case SyntaxKind.PostfixUnaryExpression:
                     case SyntaxKind.ConditionalExpression:
+                    case SyntaxKind.SpreadElementExpression:
                     case SyntaxKind.Block:
                     case SyntaxKind.VariableStatement:
                     case SyntaxKind.ExpressionStatement:
@@ -8876,6 +8877,7 @@ module ts {
                 case SyntaxKind.PostfixUnaryExpression:
                 case SyntaxKind.BinaryExpression:
                 case SyntaxKind.ConditionalExpression:
+                case SyntaxKind.SpreadElementExpression:
                 case SyntaxKind.Block:
                 case SyntaxKind.ModuleBlock:
                 case SyntaxKind.VariableStatement:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index d406b938d4e..fe9944f930d 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -356,6 +356,8 @@ module ts {
                 return child((<ConditionalExpression>node).condition) ||
                     child((<ConditionalExpression>node).whenTrue) ||
                     child((<ConditionalExpression>node).whenFalse);
+            case SyntaxKind.SpreadElementExpression:
+                return child((<SpreadElementExpression>node).expression);
             case SyntaxKind.Block:
             case SyntaxKind.TryBlock:
             case SyntaxKind.FinallyBlock:
@@ -622,6 +624,7 @@ module ts {
             case SyntaxKind.PostfixUnaryExpression:
             case SyntaxKind.BinaryExpression:
             case SyntaxKind.ConditionalExpression:
+            case SyntaxKind.SpreadElementExpression:
             case SyntaxKind.TemplateExpression:
             case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.OmittedExpression:
@@ -3354,8 +3357,15 @@ module ts {
                 : parseAssignmentExpressionOrHigher();
         }
 
+        function parseSpreadElement(): Expression {
+            var node = <SpreadElementExpression>createNode(SyntaxKind.SpreadElementExpression);
+            parseExpected(SyntaxKind.DotDotDotToken);
+            node.expression = parseAssignmentExpressionOrHigher();
+            return finishNode(node);
+        }
+
         function parseArrayLiteralElement(): Expression {
-            return parseAssignmentExpressionOrOmittedExpression();
+            return token === SyntaxKind.DotDotDotToken ? parseSpreadElement() : parseAssignmentExpressionOrOmittedExpression();
         }
 
         function parseArgumentExpression(): Expression {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 19baf052406..72514a622d1 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -192,6 +192,7 @@ module ts {
         ConditionalExpression,
         TemplateExpression,
         YieldExpression,
+        SpreadElementExpression,
         OmittedExpression,
         // Misc
         TemplateSpan,
@@ -649,7 +650,11 @@ module ts {
     export interface ArrayLiteralExpression extends PrimaryExpression {
         elements: NodeArray<Expression>;
     }
-    
+
+    export interface SpreadElementExpression extends Expression {
+        expression: Expression;
+    }
+
     // An ObjectLiteralExpression is the declaration node for an anonymous symbol.
     export interface ObjectLiteralExpression extends PrimaryExpression, Declaration {
         properties: NodeArray<ObjectLiteralElement>;