From a84c7aeea4f0109af303dfad05232011abfca212 Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 7 Nov 2016 08:36:03 -0800
Subject: [PATCH] Rename SpreadElementExpression -> SpreadAssignment

and SpreadExpression (formerly SpreadElementExpression) -> SpreadElement
---
 src/compiler/binder.ts                     | 14 +++++-----
 src/compiler/checker.ts                    | 30 +++++++++++-----------
 src/compiler/emitter.ts                    |  6 ++---
 src/compiler/factory.ts                    |  4 +--
 src/compiler/parser.ts                     | 16 ++++++------
 src/compiler/transformers/destructuring.ts |  4 +--
 src/compiler/transformers/es2015.ts        |  6 ++---
 src/compiler/transformers/esnext.ts        |  4 +--
 src/compiler/types.ts                      | 16 +++++-------
 src/compiler/utilities.ts                  | 14 +++++-----
 src/compiler/visitor.ts                    | 10 ++++----
 src/services/breakpoints.ts                |  2 +-
 src/services/utilities.ts                  |  4 +--
 13 files changed, 64 insertions(+), 66 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index b0c456a6770..902d20b0cfd 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -1138,8 +1138,8 @@ namespace ts {
             }
             else if (node.kind === SyntaxKind.ArrayLiteralExpression) {
                 for (const e of (<ArrayLiteralExpression>node).elements) {
-                    if (e.kind === SyntaxKind.SpreadExpression) {
-                        bindAssignmentTargetFlow((<SpreadExpression>e).expression);
+                    if (e.kind === SyntaxKind.SpreadElement) {
+                        bindAssignmentTargetFlow((<SpreadElement>e).expression);
                     }
                     else {
                         bindDestructuringTargetFlow(e);
@@ -1154,8 +1154,8 @@ namespace ts {
                     else if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {
                         bindAssignmentTargetFlow((<ShorthandPropertyAssignment>p).name);
                     }
-                    else if (p.kind === SyntaxKind.SpreadElementExpression) {
-                        bindAssignmentTargetFlow((<SpreadElementExpression>p).expression);
+                    else if (p.kind === SyntaxKind.SpreadAssignment) {
+                        bindAssignmentTargetFlow((<SpreadAssignment>p).expression);
                     }
                 }
             }
@@ -1929,7 +1929,7 @@ namespace ts {
                 case SyntaxKind.EnumMember:
                     return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);
 
-                case SyntaxKind.SpreadElementExpression:
+                case SyntaxKind.SpreadAssignment:
                 case SyntaxKind.JsxSpreadAttribute:
                     emitFlags |= NodeFlags.HasSpreadAttribute;
                     return;
@@ -3127,8 +3127,8 @@ namespace ts {
                 }
                 break;
 
-            case SyntaxKind.SpreadExpression:
-            case SyntaxKind.SpreadElementExpression:
+            case SyntaxKind.SpreadElement:
+            case SyntaxKind.SpreadAssignment:
                 // This node is ES6 or ES future syntax, but is handled by a containing node.
                 transformFlags |= TransformFlags.ContainsSpreadExpression;
                 break;
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 20e90f4db25..09172d02ad7 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -8640,7 +8640,7 @@ namespace ts {
             return getTypeOfDestructuredArrayElement(getAssignedType(node), indexOf(node.elements, element));
         }
 
-        function getAssignedTypeOfSpreadExpression(node: SpreadExpression): Type {
+        function getAssignedTypeOfSpreadExpression(node: SpreadElement): Type {
             return getTypeOfDestructuredSpreadExpression(getAssignedType(<ArrayLiteralExpression>node.parent));
         }
 
@@ -8665,8 +8665,8 @@ namespace ts {
                     return undefinedType;
                 case SyntaxKind.ArrayLiteralExpression:
                     return getAssignedTypeOfArrayLiteralElement(<ArrayLiteralExpression>parent, node);
-                case SyntaxKind.SpreadExpression:
-                    return getAssignedTypeOfSpreadExpression(<SpreadExpression>parent);
+                case SyntaxKind.SpreadElement:
+                    return getAssignedTypeOfSpreadExpression(<SpreadElement>parent);
                 case SyntaxKind.PropertyAssignment:
                     return getAssignedTypeOfPropertyAssignment(<PropertyAssignment>parent);
                 case SyntaxKind.ShorthandPropertyAssignment:
@@ -10697,7 +10697,7 @@ namespace ts {
             return mapper && mapper.context;
         }
 
-        function checkSpreadExpression(node: SpreadExpression, contextualMapper?: TypeMapper): Type {
+        function checkSpreadExpression(node: SpreadElement, contextualMapper?: TypeMapper): Type {
             // It is usually not safe to call checkExpressionCached if we can be contextually typing.
             // You can tell that we are contextually typing because of the contextualMapper parameter.
             // While it is true that a spread element can have a contextual type, it does not do anything
@@ -10719,7 +10719,7 @@ namespace ts {
             const elementTypes: Type[] = [];
             const inDestructuringPattern = isAssignmentTarget(node);
             for (const e of elements) {
-                if (inDestructuringPattern && e.kind === SyntaxKind.SpreadExpression) {
+                if (inDestructuringPattern && e.kind === SyntaxKind.SpreadElement) {
                     // Given the following situation:
                     //    var c: {};
                     //    [...c] = ["", 0];
@@ -10732,7 +10732,7 @@ namespace ts {
                     // get the contextual element type from it. So we do something similar to
                     // getContextualTypeForElementExpression, which will crucially not error
                     // if there is no index type / iterated type.
-                    const restArrayType = checkExpression((<SpreadExpression>e).expression, contextualMapper);
+                    const restArrayType = checkExpression((<SpreadElement>e).expression, contextualMapper);
                     const restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
                         (languageVersion >= ScriptTarget.ES2015 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
                     if (restElementType) {
@@ -10743,7 +10743,7 @@ namespace ts {
                     const type = checkExpressionForMutableLocation(e, contextualMapper);
                     elementTypes.push(type);
                 }
-                hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadExpression;
+                hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElement;
             }
             if (!hasSpreadElement) {
                 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
@@ -10927,7 +10927,7 @@ namespace ts {
                     prop.target = member;
                     member = prop;
                 }
-                else if (memberDecl.kind === SyntaxKind.SpreadElementExpression) {
+                else if (memberDecl.kind === SyntaxKind.SpreadAssignment) {
                     if (propertiesArray.length > 0) {
                         spread = getSpreadType(spread, createObjectLiteralType(), node.symbol);
                         propertiesArray = [];
@@ -10936,7 +10936,7 @@ namespace ts {
                         hasComputedNumberProperty = false;
                         typeFlags = 0;
                     }
-                    const type = checkExpression((memberDecl as SpreadElementExpression).expression);
+                    const type = checkExpression((memberDecl as SpreadAssignment).expression);
                     if (!(type.flags & (TypeFlags.Object | TypeFlags.Any))) {
                         error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);
                         return unknownType;
@@ -11905,7 +11905,7 @@ namespace ts {
         function getSpreadArgumentIndex(args: Expression[]): number {
             for (let i = 0; i < args.length; i++) {
                 const arg = args[i];
-                if (arg && arg.kind === SyntaxKind.SpreadExpression) {
+                if (arg && arg.kind === SyntaxKind.SpreadElement) {
                     return i;
                 }
             }
@@ -13893,7 +13893,7 @@ namespace ts {
             const elements = node.elements;
             const element = elements[elementIndex];
             if (element.kind !== SyntaxKind.OmittedExpression) {
-                if (element.kind !== SyntaxKind.SpreadExpression) {
+                if (element.kind !== SyntaxKind.SpreadElement) {
                     const propName = "" + elementIndex;
                     const type = isTypeAny(sourceType)
                         ? sourceType
@@ -13920,7 +13920,7 @@ namespace ts {
                         error(element, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
                     }
                     else {
-                        const restExpression = (<SpreadExpression>element).expression;
+                        const restExpression = (<SpreadElement>element).expression;
                         if (restExpression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>restExpression).operatorToken.kind === SyntaxKind.EqualsToken) {
                             error((<BinaryExpression>restExpression).operatorToken, Diagnostics.A_rest_element_cannot_have_an_initializer);
                         }
@@ -14553,8 +14553,8 @@ namespace ts {
                     return checkBinaryExpression(<BinaryExpression>node, contextualMapper);
                 case SyntaxKind.ConditionalExpression:
                     return checkConditionalExpression(<ConditionalExpression>node, contextualMapper);
-                case SyntaxKind.SpreadExpression:
-                    return checkSpreadExpression(<SpreadExpression>node, contextualMapper);
+                case SyntaxKind.SpreadElement:
+                    return checkSpreadExpression(<SpreadElement>node, contextualMapper);
                 case SyntaxKind.OmittedExpression:
                     return undefinedWideningType;
                 case SyntaxKind.YieldExpression:
@@ -20511,7 +20511,7 @@ namespace ts {
             const GetOrSetAccessor = GetAccessor | SetAccessor;
 
             for (const prop of node.properties) {
-                if (prop.kind === SyntaxKind.SpreadElementExpression) {
+                if (prop.kind === SyntaxKind.SpreadAssignment) {
                     continue;
                 }
                 const name = prop.name;
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 0ee598c507a..6d4688ac004 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -822,8 +822,8 @@ const _super = (function (geti, seti) {
                     return emitTemplateExpression(<TemplateExpression>node);
                 case SyntaxKind.YieldExpression:
                     return emitYieldExpression(<YieldExpression>node);
-                case SyntaxKind.SpreadExpression:
-                    return emitSpreadExpression(<SpreadExpression>node);
+                case SyntaxKind.SpreadElement:
+                    return emitSpreadExpression(<SpreadElement>node);
                 case SyntaxKind.ClassExpression:
                     return emitClassExpression(<ClassExpression>node);
                 case SyntaxKind.OmittedExpression:
@@ -1374,7 +1374,7 @@ const _super = (function (geti, seti) {
             emitExpressionWithPrefix(" ", node.expression);
         }
 
-        function emitSpreadExpression(node: SpreadExpression) {
+        function emitSpreadExpression(node: SpreadElement) {
             write("...");
             emitExpression(node.expression);
         }
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index c7fe7d70574..536ee4cb4b4 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -692,12 +692,12 @@ namespace ts {
     }
 
     export function createSpread(expression: Expression, location?: TextRange) {
-        const node = <SpreadExpression>createNode(SyntaxKind.SpreadExpression, location);
+        const node = <SpreadElement>createNode(SyntaxKind.SpreadElement, location);
         node.expression = parenthesizeExpressionForList(expression);
         return node;
     }
 
-    export function updateSpread(node: SpreadExpression, expression: Expression) {
+    export function updateSpread(node: SpreadElement, expression: Expression) {
         if (node.expression !== expression) {
             return updateNode(createSpread(expression, node), node);
         }
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 464f6ca01d8..9e0a5b4cd33 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -74,8 +74,8 @@ namespace ts {
                     visitNode(cbNode, (<ShorthandPropertyAssignment>node).questionToken) ||
                     visitNode(cbNode, (<ShorthandPropertyAssignment>node).equalsToken) ||
                     visitNode(cbNode, (<ShorthandPropertyAssignment>node).objectAssignmentInitializer);
-            case SyntaxKind.SpreadElementExpression:
-                return visitNode(cbNode, (<SpreadElementExpression>node).expression);
+            case SyntaxKind.SpreadAssignment:
+                return visitNode(cbNode, (<SpreadAssignment>node).expression);
             case SyntaxKind.Parameter:
             case SyntaxKind.PropertyDeclaration:
             case SyntaxKind.PropertySignature:
@@ -199,8 +199,8 @@ namespace ts {
                     visitNode(cbNode, (<ConditionalExpression>node).whenTrue) ||
                     visitNode(cbNode, (<ConditionalExpression>node).colonToken) ||
                     visitNode(cbNode, (<ConditionalExpression>node).whenFalse);
-            case SyntaxKind.SpreadExpression:
-                return visitNode(cbNode, (<SpreadExpression>node).expression);
+            case SyntaxKind.SpreadElement:
+                return visitNode(cbNode, (<SpreadElement>node).expression);
             case SyntaxKind.Block:
             case SyntaxKind.ModuleBlock:
                 return visitNodes(cbNodes, (<Block>node).statements);
@@ -4123,15 +4123,15 @@ namespace ts {
             return finishNode(node);
         }
 
-        function parseSpreadExpression(): Expression {
-            const node = <SpreadExpression>createNode(SyntaxKind.SpreadExpression);
+        function parseSpreadElement(): Expression {
+            const node = <SpreadElement>createNode(SyntaxKind.SpreadElement);
             parseExpected(SyntaxKind.DotDotDotToken);
             node.expression = parseAssignmentExpressionOrHigher();
             return finishNode(node);
         }
 
         function parseArgumentOrArrayLiteralElement(): Expression {
-            return token() === SyntaxKind.DotDotDotToken ? parseSpreadExpression() :
+            return token() === SyntaxKind.DotDotDotToken ? parseSpreadElement() :
                 token() === SyntaxKind.CommaToken ? <Expression>createNode(SyntaxKind.OmittedExpression) :
                     parseAssignmentExpressionOrHigher();
         }
@@ -4166,7 +4166,7 @@ namespace ts {
             const fullStart = scanner.getStartPos();
             const dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
             if (dotDotDotToken) {
-                const spreadElement = <SpreadElementExpression>createNode(SyntaxKind.SpreadElementExpression, fullStart);
+                const spreadElement = <SpreadAssignment>createNode(SyntaxKind.SpreadAssignment, fullStart);
                 spreadElement.expression = parseAssignmentExpressionOrHigher();
                 return addJSDocComment(finishNode(spreadElement));
             }
diff --git a/src/compiler/transformers/destructuring.ts b/src/compiler/transformers/destructuring.ts
index 89beade577d..8994a28a97e 100644
--- a/src/compiler/transformers/destructuring.ts
+++ b/src/compiler/transformers/destructuring.ts
@@ -308,11 +308,11 @@ namespace ts {
                 const e = elements[i];
                 if (e.kind !== SyntaxKind.OmittedExpression) {
                     // Assignment for target = value.propName should highligh whole property, hence use e as source map node
-                    if (e.kind !== SyntaxKind.SpreadExpression) {
+                    if (e.kind !== SyntaxKind.SpreadElement) {
                         emitDestructuringAssignment(e, createElementAccess(value, createLiteral(i)), e);
                     }
                     else if (i === numElements - 1) {
-                        emitDestructuringAssignment((<SpreadExpression>e).expression, createArraySlice(value, i), e);
+                        emitDestructuringAssignment((<SpreadElement>e).expression, createArraySlice(value, i), e);
                     }
                 }
             }
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index e262b413b4c..6869b2b5eb7 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -2890,7 +2890,7 @@ namespace ts {
          *
          * @param node A SpreadExpression node.
          */
-        function visitExpressionOfSpread(node: SpreadExpression) {
+        function visitExpressionOfSpread(node: SpreadElement) {
             return visitNode(node.expression, visitor, isExpression);
         }
 
@@ -3266,11 +3266,11 @@ namespace ts {
             }
 
             const callArgument = singleOrUndefined((<CallExpression>statementExpression).arguments);
-            if (!callArgument || !nodeIsSynthesized(callArgument) || callArgument.kind !== SyntaxKind.SpreadExpression) {
+            if (!callArgument || !nodeIsSynthesized(callArgument) || callArgument.kind !== SyntaxKind.SpreadElement) {
                 return false;
             }
 
-            const expression = (<SpreadExpression>callArgument).expression;
+            const expression = (<SpreadElement>callArgument).expression;
             return isIdentifier(expression) && expression === parameter.name;
         }
     }
diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
index 1a8ed7da5eb..38ff99fd78a 100644
--- a/src/compiler/transformers/esnext.ts
+++ b/src/compiler/transformers/esnext.ts
@@ -36,12 +36,12 @@ namespace ts {
             let chunkObject: (ShorthandPropertyAssignment | PropertyAssignment)[];
             const objects: Expression[] = [];
             for (const e of elements) {
-                if (e.kind === SyntaxKind.SpreadElementExpression) {
+                if (e.kind === SyntaxKind.SpreadAssignment) {
                     if (chunkObject) {
                         objects.push(createObjectLiteral(chunkObject));
                         chunkObject = undefined;
                     }
-                    const target = (e as SpreadElementExpression).expression;
+                    const target = (e as SpreadAssignment).expression;
                     objects.push(visitNode(target, visitor, isExpression));
                 }
                 else {
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index d3b4cb3b6e7..3f40272bd4c 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -246,7 +246,7 @@ namespace ts {
         ConditionalExpression,
         TemplateExpression,
         YieldExpression,
-        SpreadExpression,
+        SpreadElement,
         ClassExpression,
         OmittedExpression,
         ExpressionWithTypeArguments,
@@ -320,7 +320,7 @@ namespace ts {
         // Property assignments
         PropertyAssignment,
         ShorthandPropertyAssignment,
-        SpreadElementExpression,
+        SpreadAssignment,
 
         // Enum
         EnumMember,
@@ -662,7 +662,6 @@ namespace ts {
         initializer?: Expression;           // Optional initializer
     }
 
-    // @kind(SyntaxKind.PropertyDeclaration)
     export interface PropertyDeclaration extends ClassElement {
         kind: SyntaxKind.PropertyDeclaration;
         questionToken?: QuestionToken;               // Present for use with reporting a grammar error
@@ -676,7 +675,7 @@ namespace ts {
         name?: PropertyName;
     }
 
-    export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | MethodDeclaration | AccessorDeclaration | SpreadElementExpression;
+    export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | MethodDeclaration | AccessorDeclaration | SpreadAssignment;
 
     export interface PropertyAssignment extends ObjectLiteralElement {
         kind: SyntaxKind.PropertyAssignment;
@@ -695,8 +694,8 @@ namespace ts {
         objectAssignmentInitializer?: Expression;
     }
 
-    export interface SpreadElementExpression extends ObjectLiteralElement {
-        kind: SyntaxKind.SpreadElementExpression;
+    export interface SpreadAssignment extends ObjectLiteralElement {
+        kind: SyntaxKind.SpreadAssignment;
         expression: Expression;
     }
 
@@ -1285,9 +1284,8 @@ namespace ts {
         multiLine?: boolean;
     }
 
-    // @kind(SyntaxKind.SpreadExpression)
-    export interface SpreadExpression extends Expression {
-        kind: SyntaxKind.SpreadExpression;
+    export interface SpreadElement extends Expression {
+        kind: SyntaxKind.SpreadElement;
         expression: Expression;
     }
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index cd3e6ab9575..b668fe6eb15 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1179,7 +1179,7 @@ namespace ts {
             case SyntaxKind.PostfixUnaryExpression:
             case SyntaxKind.BinaryExpression:
             case SyntaxKind.ConditionalExpression:
-            case SyntaxKind.SpreadExpression:
+            case SyntaxKind.SpreadElement:
             case SyntaxKind.TemplateExpression:
             case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.OmittedExpression:
@@ -1641,7 +1641,7 @@ namespace ts {
                     return (<ForInStatement | ForOfStatement>parent).initializer === node ? AssignmentKind.Definite : AssignmentKind.None;
                 case SyntaxKind.ParenthesizedExpression:
                 case SyntaxKind.ArrayLiteralExpression:
-                case SyntaxKind.SpreadExpression:
+                case SyntaxKind.SpreadElement:
                     node = parent;
                     break;
                 case SyntaxKind.ShorthandPropertyAssignment:
@@ -2226,7 +2226,7 @@ namespace ts {
             case SyntaxKind.YieldExpression:
                 return 2;
 
-            case SyntaxKind.SpreadExpression:
+            case SyntaxKind.SpreadElement:
                 return 1;
 
             default:
@@ -3862,7 +3862,7 @@ namespace ts {
         const kind = node.kind;
         return kind === SyntaxKind.PropertyAssignment
             || kind === SyntaxKind.ShorthandPropertyAssignment
-            || kind === SyntaxKind.SpreadElementExpression
+            || kind === SyntaxKind.SpreadAssignment
             || kind === SyntaxKind.MethodDeclaration
             || kind === SyntaxKind.GetAccessor
             || kind === SyntaxKind.SetAccessor
@@ -3950,8 +3950,8 @@ namespace ts {
             || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
     }
 
-    export function isSpreadExpression(node: Node): node is SpreadExpression {
-        return node.kind === SyntaxKind.SpreadExpression;
+    export function isSpreadExpression(node: Node): node is SpreadElement {
+        return node.kind === SyntaxKind.SpreadElement;
     }
 
     export function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments {
@@ -4009,7 +4009,7 @@ namespace ts {
             || kind === SyntaxKind.YieldExpression
             || kind === SyntaxKind.ArrowFunction
             || kind === SyntaxKind.BinaryExpression
-            || kind === SyntaxKind.SpreadExpression
+            || kind === SyntaxKind.SpreadElement
             || kind === SyntaxKind.AsExpression
             || kind === SyntaxKind.OmittedExpression
             || isUnaryExpressionKind(kind);
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 4bcc697a999..0fb0b182345 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -267,9 +267,9 @@ namespace ts {
             case SyntaxKind.VoidExpression:
             case SyntaxKind.AwaitExpression:
             case SyntaxKind.YieldExpression:
-            case SyntaxKind.SpreadExpression:
+            case SyntaxKind.SpreadElement:
             case SyntaxKind.NonNullExpression:
-                result = reduceNode((<ParenthesizedExpression | DeleteExpression | TypeOfExpression | VoidExpression | AwaitExpression | YieldExpression | SpreadExpression | NonNullExpression>node).expression, f, result);
+                result = reduceNode((<ParenthesizedExpression | DeleteExpression | TypeOfExpression | VoidExpression | AwaitExpression | YieldExpression | SpreadElement | NonNullExpression>node).expression, f, result);
                 break;
 
             case SyntaxKind.PrefixUnaryExpression:
@@ -870,9 +870,9 @@ namespace ts {
                 return updateYield(<YieldExpression>node,
                     visitNode((<YieldExpression>node).expression, visitor, isExpression));
 
-            case SyntaxKind.SpreadExpression:
-                return updateSpread(<SpreadExpression>node,
-                    visitNode((<SpreadExpression>node).expression, visitor, isExpression));
+            case SyntaxKind.SpreadElement:
+                return updateSpread(<SpreadElement>node,
+                    visitNode((<SpreadElement>node).expression, visitor, isExpression));
 
             case SyntaxKind.ClassExpression:
                 return updateClassExpression(<ClassExpression>node,
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
index f1cc233e676..6825ccb6371 100644
--- a/src/services/breakpoints.ts
+++ b/src/services/breakpoints.ts
@@ -264,7 +264,7 @@ namespace ts.BreakpointResolver {
                         // a or ...c  or d: x from
                         // [a, b, ...c] or { a, b } or { d: x } from destructuring pattern
                         if ((node.kind === SyntaxKind.Identifier ||
-                            node.kind == SyntaxKind.SpreadExpression ||
+                            node.kind == SyntaxKind.SpreadElement ||
                             node.kind === SyntaxKind.PropertyAssignment ||
                             node.kind === SyntaxKind.ShorthandPropertyAssignment) &&
                             isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) {
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 2db495a51f9..cfb6aae010b 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -530,8 +530,8 @@ namespace ts {
             case SyntaxKind.DeleteExpression:
             case SyntaxKind.VoidExpression:
             case SyntaxKind.YieldExpression:
-            case SyntaxKind.SpreadExpression:
-                const unaryWordExpression = n as (TypeOfExpression | DeleteExpression | VoidExpression | YieldExpression | SpreadExpression);
+            case SyntaxKind.SpreadElement:
+                const unaryWordExpression = n as (TypeOfExpression | DeleteExpression | VoidExpression | YieldExpression | SpreadElement);
                 return isCompletedNode(unaryWordExpression.expression, sourceFile);
 
             case SyntaxKind.TaggedTemplateExpression: