unknownType;

}

return createArrayType(checkIteratedTypeOrElementType(type, /*errorNode*/ undefined, /*allowStringInput*/ false) || unknownType);

}

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

}

}

function getAssignedTypeOfPropertyAssignment(node: PropertyAssignment | ShorthandPropertyAssignment): Type {

return undefinedType;

case SyntaxKind.ArrayLiteralExpression:

return getAssignedTypeOfArrayLiteralElement(<ArrayLiteralExpression>parent, node);

case SyntaxKind.PropertyAssignment:

return getAssignedTypeOfPropertyAssignment(<PropertyAssignment>parent);

case SyntaxKind.ShorthandPropertyAssignment:

getTypeOfDestructuredProperty(parentType, node.propertyName || <Identifier>node.name) :

!node.dotDotDotToken ?

getTypeOfDestructuredArrayElement(parentType, indexOf(pattern.elements, node)) :

return getTypeWithDefault(type, node.initializer);

}

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.ES6 ? 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) {

const t = createObjectLiteralType(node, hasComputedStringProperty, hasComputedNumberProperty, propertiesArray, propertiesTable, typeFlags, patternWithComputedProperties, inDestructuringPattern) as SpreadElementType;

t.isDeclaredProperty = true;

hasComputedStringProperty = false;

hasComputedNumberProperty = false;

}

continue;

}

else {

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

switch (target.kind) {

case SyntaxKind.Identifier:

case SyntaxKind.PropertyAccessExpression:

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

}

function tryGetModuleNameFromDeclaration(declaration: ImportEqualsDeclaration | ImportDeclaration | ExportDeclaration, host: EmitHost, resolver: EmitResolver, compilerOptions: CompilerOptions) {

return tryGetModuleNameFromFile(resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions);

}

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

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

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

case SyntaxKind.SpreadTypeElement:

return visitNode(cbNode, (node as SpreadTypeElement).type);

case SyntaxKind.Parameter:

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

return addJSDocComment(finishNode(spreadElement));

}

const decorators = parseDecorators();

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

}

}

}