From a0db19749ab5316254fdfa7d3dfdaa49aee3ed7a Mon Sep 17 00:00:00 2001
From: Nathan Shively-Sanders <nathansa@microsoft.com>
Date: Mon, 26 Sep 2016 11:50:02 -0700
Subject: [PATCH] Rename Spread[Element]Expression

1. SpreadElementExpression (existing, for arrays) -> SpreadExpression
2. SpreadElement (new for object literals) -> SpreadElementExpression
---
 src/compiler/binder.ts                     | 23 +++++++------
 src/compiler/checker.ts                    | 38 +++++++++++-----------
 src/compiler/emitter.ts                    |  6 ++--
 src/compiler/factory.ts                    |  6 ++--
 src/compiler/parser.ts                     | 20 +++++-------
 src/compiler/transformers/destructuring.ts |  4 +--
 src/compiler/transformers/es6.ts           | 36 ++++++++++----------
 src/compiler/transformers/experimental.ts  |  4 +--
 src/compiler/transformers/module/system.ts |  6 ++--
 src/compiler/types.ts                      | 18 +++++-----
 src/compiler/utilities.ts                  | 14 ++++----
 src/compiler/visitor.ts                    | 12 +++----
 src/services/breakpoints.ts                |  2 +-
 src/services/utilities.ts                  |  4 +--
 14 files changed, 96 insertions(+), 97 deletions(-)

diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index d3217fd70a8..c198b5c01ff 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -1063,8 +1063,8 @@ namespace ts {
             }
             else if (node.kind === SyntaxKind.ArrayLiteralExpression) {
                 for (const e of (<ArrayLiteralExpression>node).elements) {
-                    if (e.kind === SyntaxKind.SpreadElementExpression) {
-                        bindAssignmentTargetFlow((<SpreadElementExpression>e).expression);
+                    if (e.kind === SyntaxKind.SpreadExpression) {
+                        bindAssignmentTargetFlow((<SpreadExpression>e).expression);
                     }
                     else {
                         bindDestructuringTargetFlow(e);
@@ -1079,6 +1079,9 @@ namespace ts {
                     else if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {
                         bindAssignmentTargetFlow((<ShorthandPropertyAssignment>p).name);
                     }
+                    else if (p.kind === SyntaxKind.SpreadElementExpression) {
+                        bindAssignmentTargetFlow((<SpreadElementExpression>p).expression);
+                    }
                 }
             }
         }
@@ -1825,7 +1828,7 @@ namespace ts {
                 case SyntaxKind.EnumMember:
                     return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);
 
-                case SyntaxKind.SpreadElement:
+                case SyntaxKind.SpreadElementExpression:
                 case SyntaxKind.JsxSpreadAttribute:
                     emitFlags |= NodeFlags.HasSpreadAttribute;
                     return;
@@ -2369,9 +2372,9 @@ namespace ts {
         const expression = node.expression;
         const expressionKind = expression.kind;
 
-        if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression
+        if (subtreeFlags & TransformFlags.ContainsSpreadExpression
             || isSuperOrSuperProperty(expression, expressionKind)) {
-            // If the this node contains a SpreadElementExpression, or is a super call, then it is an ES6
+            // If the this node contains a SpreadExpression, or is a super call, then it is an ES6
             // node.
             transformFlags |= TransformFlags.AssertES6;
         }
@@ -2957,10 +2960,10 @@ namespace ts {
                 }
                 break;
 
-            case SyntaxKind.SpreadElement:
+            case SyntaxKind.SpreadExpression:
             case SyntaxKind.SpreadElementExpression:
                 // This node is ES6 or ES future syntax, but is handled by a containing node.
-                transformFlags |= TransformFlags.ContainsSpreadElementExpression;
+                transformFlags |= TransformFlags.ContainsSpreadExpression;
                 break;
 
             case SyntaxKind.SuperKeyword:
@@ -2998,7 +3001,7 @@ namespace ts {
                     transformFlags |= TransformFlags.ContainsLexicalThis;
                 }
 
-                if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
+                if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
                     // If an ObjectLiteralExpression contains a spread element, then it
                     // is an ES experimental node.
                     transformFlags |= TransformFlags.AssertExperimental;
@@ -3009,8 +3012,8 @@ namespace ts {
             case SyntaxKind.ArrayLiteralExpression:
             case SyntaxKind.NewExpression:
                 excludeFlags = TransformFlags.ArrayLiteralOrCallOrNewExcludes;
-                if (subtreeFlags & TransformFlags.ContainsSpreadElementExpression) {
-                    // If the this node contains a SpreadElementExpression, then it is an ES6
+                if (subtreeFlags & TransformFlags.ContainsSpreadExpression) {
+                    // If the this node contains a SpreadExpression, then it is an ES6
                     // node.
                     transformFlags |= TransformFlags.AssertES6;
                 }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 3578aeb5e4b..1f31d58b197 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -8379,7 +8379,7 @@ namespace ts {
                 unknownType;
         }
 
-        function getTypeOfDestructuredSpreadElement(type: Type) {
+        function getTypeOfDestructuredSpreadExpression(type: Type) {
             return createArrayType(checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false) || unknownType);
         }
 
@@ -8393,8 +8393,8 @@ namespace ts {
             return getTypeOfDestructuredArrayElement(getAssignedType(node), indexOf(node.elements, element));
         }
 
-        function getAssignedTypeOfSpreadElement(node: SpreadElementExpression): Type {
-            return getTypeOfDestructuredSpreadElement(getAssignedType(<ArrayLiteralExpression>node.parent));
+        function getAssignedTypeOfSpreadExpression(node: SpreadExpression): Type {
+            return getTypeOfDestructuredSpreadExpression(getAssignedType(<ArrayLiteralExpression>node.parent));
         }
 
         function getAssignedTypeOfPropertyAssignment(node: PropertyAssignment | ShorthandPropertyAssignment): Type {
@@ -8418,8 +8418,8 @@ namespace ts {
                     return undefinedType;
                 case SyntaxKind.ArrayLiteralExpression:
                     return getAssignedTypeOfArrayLiteralElement(<ArrayLiteralExpression>parent, node);
-                case SyntaxKind.SpreadElementExpression:
-                    return getAssignedTypeOfSpreadElement(<SpreadElementExpression>parent);
+                case SyntaxKind.SpreadExpression:
+                    return getAssignedTypeOfSpreadExpression(<SpreadExpression>parent);
                 case SyntaxKind.PropertyAssignment:
                     return getAssignedTypeOfPropertyAssignment(<PropertyAssignment>parent);
                 case SyntaxKind.ShorthandPropertyAssignment:
@@ -8435,7 +8435,7 @@ namespace ts {
                 getTypeOfDestructuredProperty(parentType, node.propertyName || <Identifier>node.name) :
                 !node.dotDotDotToken ?
                     getTypeOfDestructuredArrayElement(parentType, indexOf(pattern.elements, node)) :
-                    getTypeOfDestructuredSpreadElement(parentType);
+                    getTypeOfDestructuredSpreadExpression(parentType);
             return getTypeWithDefault(type, node.initializer);
         }
 
@@ -10221,7 +10221,7 @@ namespace ts {
             return mapper && mapper.context;
         }
 
-        function checkSpreadElementExpression(node: SpreadElementExpression, contextualMapper?: TypeMapper): Type {
+        function checkSpreadExpression(node: SpreadExpression, 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
@@ -10243,7 +10243,7 @@ namespace ts {
             const elementTypes: Type[] = [];
             const inDestructuringPattern = isAssignmentTarget(node);
             for (const e of elements) {
-                if (inDestructuringPattern && e.kind === SyntaxKind.SpreadElementExpression) {
+                if (inDestructuringPattern && e.kind === SyntaxKind.SpreadExpression) {
                     // Given the following situation:
                     //    var c: {};
                     //    [...c] = ["", 0];
@@ -10256,7 +10256,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((<SpreadElementExpression>e).expression, contextualMapper);
+                    const restArrayType = checkExpression((<SpreadExpression>e).expression, contextualMapper);
                     const restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||
                         (languageVersion >= ScriptTarget.ES6 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);
                     if (restElementType) {
@@ -10267,7 +10267,7 @@ namespace ts {
                     const type = checkExpressionForMutableLocation(e, contextualMapper);
                     elementTypes.push(type);
                 }
-                hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadElementExpression;
+                hasSpreadElement = hasSpreadElement || e.kind === SyntaxKind.SpreadExpression;
             }
             if (!hasSpreadElement) {
                 // If array literal is actually a destructuring pattern, mark it as an implied type. We do this such
@@ -10456,7 +10456,7 @@ namespace ts {
                     prop.target = member;
                     member = prop;
                 }
-                else if (memberDecl.kind === SyntaxKind.SpreadElement) {
+                else if (memberDecl.kind === SyntaxKind.SpreadElementExpression) {
                     if (propertiesArray.length > 0) {
                         const t = createObjectLiteralType(node, hasComputedStringProperty, hasComputedNumberProperty, propertiesArray, propertiesTable, typeFlags, patternWithComputedProperties, inDestructuringPattern) as SpreadElementType;
                         t.isDeclaredProperty = true;
@@ -10466,7 +10466,7 @@ namespace ts {
                         hasComputedStringProperty = false;
                         hasComputedNumberProperty = false;
                     }
-                    spreads.push(checkExpression((memberDecl as SpreadElement).target) as SpreadElementType);
+                    spreads.push(checkExpression((memberDecl as SpreadElementExpression).expression) as SpreadElementType);
                     continue;
                 }
                 else {
@@ -11503,7 +11503,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.SpreadElementExpression) {
+                if (arg && arg.kind === SyntaxKind.SpreadExpression) {
                     return i;
                 }
             }
@@ -13474,7 +13474,7 @@ namespace ts {
             const elements = node.elements;
             const element = elements[elementIndex];
             if (element.kind !== SyntaxKind.OmittedExpression) {
-                if (element.kind !== SyntaxKind.SpreadElementExpression) {
+                if (element.kind !== SyntaxKind.SpreadExpression) {
                     const propName = "" + elementIndex;
                     const type = isTypeAny(sourceType)
                         ? sourceType
@@ -13501,7 +13501,7 @@ namespace ts {
                         error(element, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);
                     }
                     else {
-                        const restExpression = (<SpreadElementExpression>element).expression;
+                        const restExpression = (<SpreadExpression>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);
                         }
@@ -14137,8 +14137,8 @@ namespace ts {
                     return checkBinaryExpression(<BinaryExpression>node, contextualMapper);
                 case SyntaxKind.ConditionalExpression:
                     return checkConditionalExpression(<ConditionalExpression>node, contextualMapper);
-                case SyntaxKind.SpreadElementExpression:
-                    return checkSpreadElementExpression(<SpreadElementExpression>node, contextualMapper);
+                case SyntaxKind.SpreadExpression:
+                    return checkSpreadExpression(<SpreadExpression>node, contextualMapper);
                 case SyntaxKind.OmittedExpression:
                     return undefinedWideningType;
                 case SyntaxKind.YieldExpression:
@@ -20048,8 +20048,8 @@ namespace ts {
             const GetOrSetAccessor = GetAccessor | SetAccessor;
 
             for (const prop of node.properties) {
-                if (prop.kind === SyntaxKind.SpreadElement) {
-                    const target = (prop as SpreadElement).target;
+                if (prop.kind === SyntaxKind.SpreadElementExpression) {
+                    const target = (prop as SpreadElementExpression).expression;
                     switch (target.kind) {
                         case SyntaxKind.Identifier:
                         case SyntaxKind.PropertyAccessExpression:
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index cd00f7ad769..cc574414beb 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -824,8 +824,8 @@ const _super = (function (geti, seti) {
                     return emitTemplateExpression(<TemplateExpression>node);
                 case SyntaxKind.YieldExpression:
                     return emitYieldExpression(<YieldExpression>node);
-                case SyntaxKind.SpreadElementExpression:
-                    return emitSpreadElementExpression(<SpreadElementExpression>node);
+                case SyntaxKind.SpreadExpression:
+                    return emitSpreadExpression(<SpreadExpression>node);
                 case SyntaxKind.ClassExpression:
                     return emitClassExpression(<ClassExpression>node);
                 case SyntaxKind.OmittedExpression:
@@ -1365,7 +1365,7 @@ const _super = (function (geti, seti) {
             emitExpressionWithPrefix(" ", node.expression);
         }
 
-        function emitSpreadElementExpression(node: SpreadElementExpression) {
+        function emitSpreadExpression(node: SpreadExpression) {
             write("...");
             emitExpression(node.expression);
         }
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 16eeb86f59a..a8ee15c12c4 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -704,12 +704,12 @@ namespace ts {
     }
 
     export function createSpread(expression: Expression, location?: TextRange) {
-        const node = <SpreadElementExpression>createNode(SyntaxKind.SpreadElementExpression, location);
+        const node = <SpreadExpression>createNode(SyntaxKind.SpreadExpression, location);
         node.expression = parenthesizeExpressionForList(expression);
         return node;
     }
 
-    export function updateSpread(node: SpreadElementExpression, expression: Expression) {
+    export function updateSpread(node: SpreadExpression, expression: Expression) {
         if (node.expression !== expression) {
             return updateNode(createSpread(expression, node), node);
         }
@@ -2745,4 +2745,4 @@ namespace ts {
     function tryGetModuleNameFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration, host: EmitHost, resolver: EmitResolver, compilerOptions: CompilerOptions) {
         return tryGetModuleNameFromFile(resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);
     }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index ae88b6d948b..e0d8790d14c 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -74,9 +74,8 @@ namespace ts {
                     visitNode(cbNode, (<ShorthandPropertyAssignment>node).questionToken) ||
                     visitNode(cbNode, (<ShorthandPropertyAssignment>node).equalsToken) ||
                     visitNode(cbNode, (<ShorthandPropertyAssignment>node).objectAssignmentInitializer);
-            case SyntaxKind.SpreadElement:
-                return visitNode(cbNode, (<SpreadElement>node).dotDotDotToken) ||
-                    visitNode(cbNode, (<SpreadElement>node).target);
+            case SyntaxKind.SpreadElementExpression:
+                return visitNode(cbNode, (<SpreadElementExpression>node).expression);
             case SyntaxKind.SpreadTypeElement:
                 return visitNode(cbNode, (node as SpreadTypeElement).type);
             case SyntaxKind.Parameter:
@@ -198,8 +197,8 @@ namespace ts {
                     visitNode(cbNode, (<ConditionalExpression>node).whenTrue) ||
                     visitNode(cbNode, (<ConditionalExpression>node).colonToken) ||
                     visitNode(cbNode, (<ConditionalExpression>node).whenFalse);
-            case SyntaxKind.SpreadElementExpression:
-                return visitNode(cbNode, (<SpreadElementExpression>node).expression);
+            case SyntaxKind.SpreadExpression:
+                return visitNode(cbNode, (<SpreadExpression>node).expression);
             case SyntaxKind.Block:
             case SyntaxKind.ModuleBlock:
                 return visitNodes(cbNodes, (<Block>node).statements);
@@ -4102,15 +4101,15 @@ namespace ts {
             return finishNode(node);
         }
 
-        function parseSpreadElement(): Expression {
-            const node = <SpreadElementExpression>createNode(SyntaxKind.SpreadElementExpression);
+        function parseSpreadExpression(): Expression {
+            const node = <SpreadExpression>createNode(SyntaxKind.SpreadExpression);
             parseExpected(SyntaxKind.DotDotDotToken);
             node.expression = parseAssignmentExpressionOrHigher();
             return finishNode(node);
         }
 
         function parseArgumentOrArrayLiteralElement(): Expression {
-            return token() === SyntaxKind.DotDotDotToken ? parseSpreadElement() :
+            return token() === SyntaxKind.DotDotDotToken ? parseSpreadExpression() :
                 token() === SyntaxKind.CommaToken ? <Expression>createNode(SyntaxKind.OmittedExpression) :
                     parseAssignmentExpressionOrHigher();
         }
@@ -4145,9 +4144,8 @@ namespace ts {
             const fullStart = scanner.getStartPos();
             const dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);
             if (dotDotDotToken) {
-                const spreadElement = <SpreadElement>createNode(SyntaxKind.SpreadElement, fullStart);
-                spreadElement.dotDotDotToken = dotDotDotToken;
-                spreadElement.target = parseAssignmentExpressionOrHigher();
+                const spreadElement = <SpreadElementExpression>createNode(SyntaxKind.SpreadElementExpression, fullStart);
+                spreadElement.expression = parseAssignmentExpressionOrHigher();
                 return addJSDocComment(finishNode(spreadElement));
             }
             const decorators = parseDecorators();
diff --git a/src/compiler/transformers/destructuring.ts b/src/compiler/transformers/destructuring.ts
index a66f5e21d78..7d74e58f204 100644
--- a/src/compiler/transformers/destructuring.ts
+++ b/src/compiler/transformers/destructuring.ts
@@ -310,11 +310,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.SpreadElementExpression) {
+                    if (e.kind !== SyntaxKind.SpreadExpression) {
                         emitDestructuringAssignment(e, createElementAccess(value, createLiteral(i)), e);
                     }
                     else if (i === numElements - 1) {
-                        emitDestructuringAssignment((<SpreadElementExpression>e).expression, createArraySlice(value, i), e);
+                        emitDestructuringAssignment((<SpreadExpression>e).expression, createArraySlice(value, i), e);
                     }
                 }
             }
diff --git a/src/compiler/transformers/es6.ts b/src/compiler/transformers/es6.ts
index 114a3aea546..7582b14e4aa 100644
--- a/src/compiler/transformers/es6.ts
+++ b/src/compiler/transformers/es6.ts
@@ -2556,7 +2556,7 @@ namespace ts {
             // because we contain a SpreadElementExpression.
 
             const { target, thisArg } = createCallBinding(node.expression, hoistVariableDeclaration);
-            if (node.transformFlags & TransformFlags.ContainsSpreadElementExpression) {
+            if (node.transformFlags & TransformFlags.ContainsSpreadExpression) {
                 // [source]
                 //      f(...a, b)
                 //      x.m(...a, b)
@@ -2604,7 +2604,7 @@ namespace ts {
          */
         function visitNewExpression(node: NewExpression): LeftHandSideExpression {
             // We are here because we contain a SpreadElementExpression.
-            Debug.assert((node.transformFlags & TransformFlags.ContainsSpreadElementExpression) !== 0);
+            Debug.assert((node.transformFlags & TransformFlags.ContainsSpreadExpression) !== 0);
 
             // [source]
             //      new C(...a)
@@ -2625,7 +2625,7 @@ namespace ts {
         }
 
         /**
-         * Transforms an array of Expression nodes that contains a SpreadElementExpression.
+         * Transforms an array of Expression nodes that contains a SpreadExpression.
          *
          * @param elements The array of Expression nodes.
          * @param needsUniqueCopy A value indicating whether to ensure that the result is a fresh array.
@@ -2642,14 +2642,14 @@ namespace ts {
             // expressions into an array literal.
             const numElements = elements.length;
             const segments = flatten(
-                spanMap(elements, partitionSpreadElement, (partition, visitPartition, start, end) =>
+                spanMap(elements, partitionSpread, (partition, visitPartition, start, end) =>
                     visitPartition(partition, multiLine, hasTrailingComma && end === numElements)
                 )
             );
 
             if (segments.length === 1) {
                 const firstElement = elements[0];
-                return needsUniqueCopy && isSpreadElementExpression(firstElement) && firstElement.expression.kind !== SyntaxKind.ArrayLiteralExpression
+                return needsUniqueCopy && isSpreadExpression(firstElement) && firstElement.expression.kind !== SyntaxKind.ArrayLiteralExpression
                     ? createArraySlice(segments[0])
                     : segments[0];
             }
@@ -2658,17 +2658,17 @@ namespace ts {
             return createArrayConcat(segments.shift(), segments);
         }
 
-        function partitionSpreadElement(node: Expression) {
-            return isSpreadElementExpression(node)
-                ? visitSpanOfSpreadElements
-                : visitSpanOfNonSpreadElements;
+        function partitionSpread(node: Expression) {
+            return isSpreadExpression(node)
+                ? visitSpanOfSpreads
+                : visitSpanOfNonSpreads;
         }
 
-        function visitSpanOfSpreadElements(chunk: Expression[], multiLine: boolean, hasTrailingComma: boolean): VisitResult<Expression> {
-            return map(chunk, visitExpressionOfSpreadElement);
+        function visitSpanOfSpreads(chunk: Expression[], multiLine: boolean, hasTrailingComma: boolean): VisitResult<Expression> {
+            return map(chunk, visitExpressionOfSpread);
         }
 
-        function visitSpanOfNonSpreadElements(chunk: Expression[], multiLine: boolean, hasTrailingComma: boolean): VisitResult<Expression> {
+        function visitSpanOfNonSpreads(chunk: Expression[], multiLine: boolean, hasTrailingComma: boolean): VisitResult<Expression> {
             return createArrayLiteral(
                 visitNodes(createNodeArray(chunk, /*location*/ undefined, hasTrailingComma), visitor, isExpression),
                 /*location*/ undefined,
@@ -2677,11 +2677,11 @@ namespace ts {
         }
 
         /**
-         * Transforms the expression of a SpreadElementExpression node.
+         * Transforms the expression of a SpreadExpression node.
          *
-         * @param node A SpreadElementExpression node.
+         * @param node A SpreadExpression node.
          */
-        function visitExpressionOfSpreadElement(node: SpreadElementExpression) {
+        function visitExpressionOfSpread(node: SpreadExpression) {
             return visitNode(node.expression, visitor, isExpression);
         }
 
@@ -3096,12 +3096,12 @@ namespace ts {
             }
 
             const callArgument = singleOrUndefined((<CallExpression>statementExpression).arguments);
-            if (!callArgument || !nodeIsSynthesized(callArgument) || callArgument.kind !== SyntaxKind.SpreadElementExpression) {
+            if (!callArgument || !nodeIsSynthesized(callArgument) || callArgument.kind !== SyntaxKind.SpreadExpression) {
                 return false;
             }
 
-            const expression = (<SpreadElementExpression>callArgument).expression;
+            const expression = (<SpreadExpression>callArgument).expression;
             return isIdentifier(expression) && expression === parameter.name;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/transformers/experimental.ts b/src/compiler/transformers/experimental.ts
index 715cf91afd3..85af37709c7 100644
--- a/src/compiler/transformers/experimental.ts
+++ b/src/compiler/transformers/experimental.ts
@@ -36,12 +36,12 @@ namespace ts {
             let chunkObject: (ShorthandPropertyAssignment | PropertyAssignment)[];
             const objects: Expression[] = [];
             for (const e of elements) {
-                if (e.kind === SyntaxKind.SpreadElement) {
+                if (e.kind === SyntaxKind.SpreadElementExpression) {
                     if (chunkObject) {
                         objects.push(createObjectLiteral(chunkObject));
                         chunkObject = undefined;
                     }
-                    const target = (e as SpreadElement).target;
+                    const target = (e as SpreadElementExpression).expression;
                     objects.push(visitNode(target, visitor, isExpression));
                 }
                 else {
diff --git a/src/compiler/transformers/module/system.ts b/src/compiler/transformers/module/system.ts
index 7b013e18e7d..de1522a0150 100644
--- a/src/compiler/transformers/module/system.ts
+++ b/src/compiler/transformers/module/system.ts
@@ -1120,7 +1120,7 @@ namespace ts {
         }
 
         function hasExportedReferenceInArrayDestructuringElement(node: Expression): boolean {
-            if (isSpreadElementExpression(node)) {
+            if (isSpreadExpression(node)) {
                 const expression = node.expression;
                 return isIdentifier(expression) && isExportedBinding(expression);
             }
@@ -1139,7 +1139,7 @@ namespace ts {
             else if (isIdentifier(node)) {
                 return isExportedBinding(node);
             }
-            else if (isSpreadElementExpression(node)) {
+            else if (isSpreadExpression(node)) {
                 const expression = node.expression;
                 return isIdentifier(expression) && isExportedBinding(expression);
             }
@@ -1400,4 +1400,4 @@ namespace ts {
             return updated;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index cdf42ebea4f..bfadea31794 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -241,7 +241,7 @@ namespace ts {
         ConditionalExpression,
         TemplateExpression,
         YieldExpression,
-        SpreadElementExpression,
+        SpreadExpression,
         ClassExpression,
         OmittedExpression,
         ExpressionWithTypeArguments,
@@ -316,8 +316,8 @@ namespace ts {
         // Property assignments
         PropertyAssignment,
         ShorthandPropertyAssignment,
-        SpreadElement, // maybe name it SpreadProperty?
-        SpreadTypeElement, // maybe name it SpreadTypeNode?
+        SpreadElementExpression,
+        SpreadTypeElement,
 
 
         // Enum
@@ -674,9 +674,7 @@ namespace ts {
     }
 
     // @kind(SyntaxKind.SpreadElementExpression)
-    export interface SpreadElement extends ObjectLiteralElement {
-        dotDotDotToken: Node;
-        target: Expression;
+    export interface SpreadElementExpression extends ObjectLiteralElement, SpreadExpression {
     }
 
     // SyntaxKind.VariableDeclaration
@@ -1056,8 +1054,8 @@ namespace ts {
         multiLine?: boolean;
     }
 
-    // @kind(SyntaxKind.SpreadElementExpression)
-    export interface SpreadElementExpression extends Expression {
+    // @kind(SyntaxKind.SpreadExpression)
+    export interface SpreadExpression extends Expression {
         expression: Expression;
     }
 
@@ -3140,7 +3138,7 @@ namespace ts {
         ContainsLexicalThisInComputedPropertyName = 1 << 17,
         ContainsDefaultValueAssignments = 1 << 18,
         ContainsParameterPropertyAssignments = 1 << 19,
-        ContainsSpreadElementExpression = 1 << 20,
+        ContainsSpreadExpression = 1 << 20,
         ContainsComputedPropertyName = 1 << 21,
         ContainsBlockScopedBinding = 1 << 22,
         ContainsBindingPattern = 1 << 23,
@@ -3170,7 +3168,7 @@ namespace ts {
         ModuleExcludes = NodeExcludes | ContainsDecorators | ContainsLexicalThis | ContainsCapturedLexicalThis | ContainsBlockScopedBinding | ContainsHoistedDeclarationOrCompletion,
         TypeExcludes = ~ContainsTypeScript,
         ObjectLiteralExcludes = NodeExcludes | ContainsDecorators | ContainsComputedPropertyName | ContainsLexicalThisInComputedPropertyName,
-        ArrayLiteralOrCallOrNewExcludes = NodeExcludes | ContainsSpreadElementExpression,
+        ArrayLiteralOrCallOrNewExcludes = NodeExcludes | ContainsSpreadExpression,
         VariableDeclarationListExcludes = NodeExcludes | ContainsBindingPattern,
         ParameterExcludes = NodeExcludes | ContainsBindingPattern,
 
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 67ea182bf98..30a09ade0f5 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -1178,7 +1178,7 @@ namespace ts {
             case SyntaxKind.PostfixUnaryExpression:
             case SyntaxKind.BinaryExpression:
             case SyntaxKind.ConditionalExpression:
-            case SyntaxKind.SpreadElementExpression:
+            case SyntaxKind.SpreadExpression:
             case SyntaxKind.TemplateExpression:
             case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.OmittedExpression:
@@ -1633,7 +1633,7 @@ namespace ts {
         }
         while (true) {
             const parent = node.parent;
-            if (parent.kind === SyntaxKind.ArrayLiteralExpression || parent.kind === SyntaxKind.SpreadElementExpression) {
+            if (parent.kind === SyntaxKind.ArrayLiteralExpression || parent.kind === SyntaxKind.SpreadExpression) {
                 node = parent;
                 continue;
             }
@@ -2209,7 +2209,7 @@ namespace ts {
             case SyntaxKind.YieldExpression:
                 return 2;
 
-            case SyntaxKind.SpreadElementExpression:
+            case SyntaxKind.SpreadExpression:
                 return 1;
 
             default:
@@ -3740,7 +3740,7 @@ namespace ts {
         const kind = node.kind;
         return kind === SyntaxKind.PropertyAssignment
             || kind === SyntaxKind.ShorthandPropertyAssignment
-            || kind === SyntaxKind.SpreadElement
+            || kind === SyntaxKind.SpreadElementExpression
             || kind === SyntaxKind.MethodDeclaration
             || kind === SyntaxKind.GetAccessor
             || kind === SyntaxKind.SetAccessor
@@ -3820,8 +3820,8 @@ namespace ts {
             || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
     }
 
-    export function isSpreadElementExpression(node: Node): node is SpreadElementExpression {
-        return node.kind === SyntaxKind.SpreadElementExpression;
+    export function isSpreadExpression(node: Node): node is SpreadExpression {
+        return node.kind === SyntaxKind.SpreadExpression;
     }
 
     export function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments {
@@ -3879,7 +3879,7 @@ namespace ts {
             || kind === SyntaxKind.YieldExpression
             || kind === SyntaxKind.ArrowFunction
             || kind === SyntaxKind.BinaryExpression
-            || kind === SyntaxKind.SpreadElementExpression
+            || kind === SyntaxKind.SpreadExpression
             || kind === SyntaxKind.AsExpression
             || kind === SyntaxKind.OmittedExpression
             || isUnaryExpressionKind(kind);
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 1e0cadaaa6b..691e13b03d6 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.SpreadElementExpression:
+            case SyntaxKind.SpreadExpression:
             case SyntaxKind.NonNullExpression:
-                result = reduceNode((<ParenthesizedExpression | DeleteExpression | TypeOfExpression | VoidExpression | AwaitExpression | YieldExpression | SpreadElementExpression | NonNullExpression>node).expression, f, result);
+                result = reduceNode((<ParenthesizedExpression | DeleteExpression | TypeOfExpression | VoidExpression | AwaitExpression | YieldExpression | SpreadExpression | NonNullExpression>node).expression, f, result);
                 break;
 
             case SyntaxKind.PrefixUnaryExpression:
@@ -869,9 +869,9 @@ namespace ts {
                 return updateYield(<YieldExpression>node,
                     visitNode((<YieldExpression>node).expression, visitor, isExpression));
 
-            case SyntaxKind.SpreadElementExpression:
-                return updateSpread(<SpreadElementExpression>node,
-                    visitNode((<SpreadElementExpression>node).expression, visitor, isExpression));
+            case SyntaxKind.SpreadExpression:
+                return updateSpread(<SpreadExpression>node,
+                    visitNode((<SpreadExpression>node).expression, visitor, isExpression));
 
             case SyntaxKind.ClassExpression:
                 return updateClassExpression(<ClassExpression>node,
@@ -1357,4 +1357,4 @@ namespace ts {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts
index bf7fb981daa..f1cc233e676 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.SpreadElementExpression ||
+                            node.kind == SyntaxKind.SpreadExpression ||
                             node.kind === SyntaxKind.PropertyAssignment ||
                             node.kind === SyntaxKind.ShorthandPropertyAssignment) &&
                             isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) {
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index d1f3a54563f..e5de4437a5e 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.SpreadElementExpression:
-                const unaryWordExpression = (<TypeOfExpression | DeleteExpression | VoidExpression | YieldExpression | SpreadElementExpression>n);
+            case SyntaxKind.SpreadExpression:
+                const unaryWordExpression = n as (TypeOfExpression | DeleteExpression | VoidExpression | YieldExpression | SpreadExpression);
                 return isCompletedNode(unaryWordExpression.expression, sourceFile);
 
             case SyntaxKind.TaggedTemplateExpression: