}

else if (node.kind === SyntaxKind.ArrayLiteralExpression) {

for (const e of (<ArrayLiteralExpression>node).elements) {

}

else {

bindDestructuringTargetFlow(e);

else if (p.kind === SyntaxKind.ShorthandPropertyAssignment) {

bindAssignmentTargetFlow((<ShorthandPropertyAssignment>p).name);

}

}

}

}

case SyntaxKind.EnumMember:

return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes);

case SyntaxKind.JsxSpreadAttribute:

emitFlags |= NodeFlags.HasSpreadAttribute;

return;

}

break;

// This node is ES6 or ES future syntax, but is handled by a containing node.

transformFlags |= TransformFlags.ContainsSpreadExpression;

break;

return getTypeOfDestructuredArrayElement(getAssignedType(node), indexOf(node.elements, element));

}

return getTypeOfDestructuredSpreadExpression(getAssignedType(<ArrayLiteralExpression>node.parent));

}

return undefinedType;

case SyntaxKind.ArrayLiteralExpression:

return getAssignedTypeOfArrayLiteralElement(<ArrayLiteralExpression>parent, node);

case SyntaxKind.PropertyAssignment:

return getAssignedTypeOfPropertyAssignment(<PropertyAssignment>parent);

case SyntaxKind.ShorthandPropertyAssignment:

return mapper && mapper.context;

}

// 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

const elementTypes: Type[] = [];

const inDestructuringPattern = isAssignmentTarget(node);

for (const e of elements) {

// Given the following situation:

// var c: {};

// [...c] = ["", 0];

// 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 restElementType = getIndexTypeOfType(restArrayType, IndexKind.Number) ||

(languageVersion >= ScriptTarget.ES2015 ? getElementTypeOfIterable(restArrayType, /*errorNode*/ undefined) : undefined);

if (restElementType) {

const type = checkExpressionForMutableLocation(e, contextualMapper);

elementTypes.push(type);

}

}

if (!hasSpreadElement) {

// If array literal is actually a destructuring pattern, mark it as an implied type. We do this such

prop.target = member;

member = prop;

}

if (propertiesArray.length > 0) {

spread = getSpreadType(spread, createObjectLiteralType(), node.symbol);

propertiesArray = [];

hasComputedNumberProperty = false;

typeFlags = 0;

}

if (!(type.flags & (TypeFlags.Object | TypeFlags.Any))) {

error(memberDecl, Diagnostics.Spread_types_may_only_be_created_from_object_types);

return unknownType;

function getSpreadArgumentIndex(args: Expression[]): number {

for (let i = 0; i < args.length; i++) {

const arg = args[i];

return i;

}

}

const elements = node.elements;

const element = elements[elementIndex];

if (element.kind !== SyntaxKind.OmittedExpression) {

const propName = "" + elementIndex;

const type = isTypeAny(sourceType)

? sourceType

error(element, Diagnostics.A_rest_element_must_be_last_in_an_array_destructuring_pattern);

}

else {

if (restExpression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>restExpression).operatorToken.kind === SyntaxKind.EqualsToken) {

error((<BinaryExpression>restExpression).operatorToken, Diagnostics.A_rest_element_cannot_have_an_initializer);

}

return checkBinaryExpression(<BinaryExpression>node, contextualMapper);

case SyntaxKind.ConditionalExpression:

return checkConditionalExpression(<ConditionalExpression>node, contextualMapper);

case SyntaxKind.OmittedExpression:

return undefinedWideningType;

case SyntaxKind.YieldExpression:

const GetOrSetAccessor = GetAccessor | SetAccessor;

for (const prop of node.properties) {

continue;

}

const name = prop.name;

return emitTemplateExpression(<TemplateExpression>node);

case SyntaxKind.YieldExpression:

return emitYieldExpression(<YieldExpression>node);

case SyntaxKind.ClassExpression:

return emitClassExpression(<ClassExpression>node);

case SyntaxKind.OmittedExpression:

emitExpressionWithPrefix(" ", node.expression);

}

write("...");

emitExpression(node.expression);

}

}

export function createSpread(expression: Expression, location?: TextRange) {

node.expression = parenthesizeExpressionForList(expression);

return node;

}

if (node.expression !== expression) {

return updateNode(createSpread(expression, node), node);

}

visitNode(cbNode, (<ShorthandPropertyAssignment>node).questionToken) ||

visitNode(cbNode, (<ShorthandPropertyAssignment>node).equalsToken) ||

visitNode(cbNode, (<ShorthandPropertyAssignment>node).objectAssignmentInitializer);

case SyntaxKind.Parameter:

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.PropertySignature:

visitNode(cbNode, (<ConditionalExpression>node).whenTrue) ||

visitNode(cbNode, (<ConditionalExpression>node).colonToken) ||

visitNode(cbNode, (<ConditionalExpression>node).whenFalse);

case SyntaxKind.Block:

case SyntaxKind.ModuleBlock:

return visitNodes(cbNodes, (<Block>node).statements);

return finishNode(node);

}

parseExpected(SyntaxKind.DotDotDotToken);

node.expression = parseAssignmentExpressionOrHigher();

return finishNode(node);

}

function parseArgumentOrArrayLiteralElement(): Expression {

token() === SyntaxKind.CommaToken ? <Expression>createNode(SyntaxKind.OmittedExpression) :

parseAssignmentExpressionOrHigher();

}

const fullStart = scanner.getStartPos();

const dotDotDotToken = parseOptionalToken(SyntaxKind.DotDotDotToken);

if (dotDotDotToken) {

spreadElement.expression = parseAssignmentExpressionOrHigher();

return addJSDocComment(finishNode(spreadElement));

}

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

emitDestructuringAssignment(e, createElementAccess(value, createLiteral(i)), e);

}

else if (i === numElements - 1) {

}

}

}

return visitNode(node.expression, visitor, isExpression);

}

}

const callArgument = singleOrUndefined((<CallExpression>statementExpression).arguments);

return false;

}

return isIdentifier(expression) && expression === parameter.name;

}

}

let chunkObject: (ShorthandPropertyAssignment | PropertyAssignment)[];

const objects: Expression[] = [];

for (const e of elements) {

if (chunkObject) {

objects.push(createObjectLiteral(chunkObject));

chunkObject = undefined;

}

objects.push(visitNode(target, visitor, isExpression));

}

else {

ConditionalExpression,

TemplateExpression,

YieldExpression,

ClassExpression,

OmittedExpression,

ExpressionWithTypeArguments,

// Property assignments

PropertyAssignment,

ShorthandPropertyAssignment,

// Enum

EnumMember,

initializer?: Expression; // Optional initializer

}

export interface PropertyDeclaration extends ClassElement {

kind: SyntaxKind.PropertyDeclaration;

questionToken?: QuestionToken; // Present for use with reporting a grammar error

name?: PropertyName;

}

export interface PropertyAssignment extends ObjectLiteralElement {

kind: SyntaxKind.PropertyAssignment;

objectAssignmentInitializer?: Expression;

}

expression: Expression;

}

multiLine?: boolean;

}

expression: Expression;

}