microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2026-02-16 05:58:32 -06:00
Code Issues Packages Projects Releases 212 Wiki Activity

Rename Spread[Element]Expression

Browse Source 
1. SpreadElementExpression (existing, for arrays) -> SpreadExpression
2. SpreadElement (new for object literals) -> SpreadElementExpression
This commit is contained in:
Nathan Shively-Sanders 2016-09-26 11:50:02 -07:00
parent 63f8c99173
commit a0db19749a
14 changed files with 96 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
src/compiler/binder.ts
View File

@ -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;
}

38
src/compiler/checker.ts
View File

@ -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:

6
src/compiler/emitter.ts
View File

@ -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);
}

6
src/compiler/factory.ts
View File

@ -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);
}
}
}

20
src/compiler/parser.ts
View File

@ -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();

4
src/compiler/transformers/destructuring.ts
View File

@ -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);
}
}
}

36
src/compiler/transformers/es6.ts
View File

@ -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;
}
}
}
}

4
src/compiler/transformers/experimental.ts
View File

@ -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 {

6
src/compiler/transformers/module/system.ts
View File

@ -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;
}
}
}
}

18
src/compiler/types.ts
View File

@ -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,

14
src/compiler/utilities.ts
View File

@ -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);

12
src/compiler/visitor.ts
View File

@ -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 {
}
}
}
}
}

2
src/services/breakpoints.ts
View File

@ -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)) {

4
src/services/utilities.ts
View File

@ -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: