/// <reference path="core.ts"/>

/// <reference path="utilities.ts"/>

namespace ts {

function createSynthesizedNode(kind: SyntaxKind): Node {

const node = createNode(kind, -1, -1);

node.flags |= NodeFlags.Synthesized;

return node;

}

/* @internal */

export function updateNode<T extends Node>(updated: T, original: T): T {

if (updated !== original) {

setOriginalNode(updated, original);

setTextRange(updated, original);

if (original.startsOnNewLine) {

updated.startsOnNewLine = true;

}

aggregateTransformFlags(updated);

}

return updated;

}

/* @internal */ export function createNodeArray<T extends Node>(elements?: T[], hasTrailingComma?: boolean): MutableNodeArray<T>;

export function createNodeArray<T extends Node>(elements?: ReadonlyArray<T>, hasTrailingComma?: boolean): NodeArray<T>;

/**

* Make `elements` into a `NodeArray<T>`. If `elements` is `undefined`, returns an empty `NodeArray<T>`.

*/

export function createNodeArray<T extends Node>(elements?: ReadonlyArray<T>, hasTrailingComma?: boolean): NodeArray<T> {

if (elements) {

if (isNodeArray(elements)) {

return elements;

}

}

else {

elements = [];

}

const array = <NodeArray<T>>elements;

array.pos = -1;

array.end = -1;

array.hasTrailingComma = hasTrailingComma;

return array;

}

/**

* Creates a shallow, memberwise clone of a node with no source map location.

*/

/* @internal */

export function getSynthesizedClone<T extends Node>(node: T | undefined): T | undefined {

// We don't use "clone" from core.ts here, as we need to preserve the prototype chain of

// the original node. We also need to exclude specific properties and only include own-

// properties (to skip members already defined on the shared prototype).

if (node === undefined) {

return undefined;

}

const clone = <T>createSynthesizedNode(node.kind);

clone.flags |= node.flags;

setOriginalNode(clone, node);

for (const key in node) {

if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {

continue;

}

(<any>clone)[key] = (<any>node)[key];

}

return clone;

}

// Literals

export function createLiteral(value: string): StringLiteral;

export function createLiteral(value: number): NumericLiteral;

export function createLiteral(value: boolean): BooleanLiteral;

/** Create a string literal whose source text is read from a source node during emit. */

export function createLiteral(sourceNode: StringLiteral | NumericLiteral | Identifier): StringLiteral;

export function createLiteral(value: string | number | boolean): PrimaryExpression;

export function createLiteral(value: string | number | boolean | StringLiteral | NumericLiteral | Identifier): PrimaryExpression {

if (typeof value === "number") {

return createNumericLiteral(value + "");

}

if (typeof value === "boolean") {

return value ? createTrue() : createFalse();

}

if (isString(value)) {

return createStringLiteral(value);

}

return createLiteralFromNode(value);

}

export function createNumericLiteral(value: string): NumericLiteral {

const node = <NumericLiteral>createSynthesizedNode(SyntaxKind.NumericLiteral);

node.text = value;

node.numericLiteralFlags = 0;

return node;

}

function createStringLiteral(text: string): StringLiteral {

const node = <StringLiteral>createSynthesizedNode(SyntaxKind.StringLiteral);

node.text = text;

return node;

}

function createLiteralFromNode(sourceNode: StringLiteral | NumericLiteral | Identifier): StringLiteral {

const node = createStringLiteral(getTextOfIdentifierOrLiteral(sourceNode));

node.textSourceNode = sourceNode;

return node;

}

// Identifiers

export function createIdentifier(text: string): Identifier;

/* @internal */

export function createIdentifier(text: string, typeArguments: ReadonlyArray<TypeNode>): Identifier;

export function createIdentifier(text: string, typeArguments?: ReadonlyArray<TypeNode>): Identifier {

const node = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);

node.escapedText = escapeLeadingUnderscores(text);

node.originalKeywordKind = text ? stringToToken(text) : SyntaxKind.Unknown;

node.autoGenerateKind = GeneratedIdentifierKind.None;

node.autoGenerateId = 0;

if (typeArguments) {

node.typeArguments = createNodeArray(typeArguments);

}

return node;

}

export function updateIdentifier(node: Identifier, typeArguments: NodeArray<TypeNode> | undefined): Identifier {

return node.typeArguments !== typeArguments

? updateNode(createIdentifier(idText(node), typeArguments), node)

: node;

}

let nextAutoGenerateId = 0;

/** Create a unique temporary variable. */

export function createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined): Identifier {

const name = createIdentifier("");

name.autoGenerateKind = GeneratedIdentifierKind.Auto;

name.autoGenerateId = nextAutoGenerateId;

nextAutoGenerateId++;

if (recordTempVariable) {

recordTempVariable(name);

}

return name;

}

/** Create a unique temporary variable for use in a loop. */

export function createLoopVariable(): Identifier {

const name = createIdentifier("");

name.autoGenerateKind = GeneratedIdentifierKind.Loop;

name.autoGenerateId = nextAutoGenerateId;

nextAutoGenerateId++;

return name;

}

/** Create a unique name based on the supplied text. */

export function createUniqueName(text: string): Identifier {

const name = createIdentifier(text);

name.autoGenerateKind = GeneratedIdentifierKind.Unique;

name.autoGenerateId = nextAutoGenerateId;

nextAutoGenerateId++;

return name;

}

/** Create a unique name generated for a node. */

export function getGeneratedNameForNode(node: Node): Identifier {

const name = createIdentifier("");

name.autoGenerateKind = GeneratedIdentifierKind.Node;

name.autoGenerateId = nextAutoGenerateId;

name.original = node;

nextAutoGenerateId++;

return name;

}

// Punctuation

export function createToken<TKind extends SyntaxKind>(token: TKind) {

return <Token<TKind>>createSynthesizedNode(token);

}

// Reserved words

export function createSuper() {

return <SuperExpression>createSynthesizedNode(SyntaxKind.SuperKeyword);

}

export function createThis() {

return <ThisExpression & Token<SyntaxKind.ThisKeyword>>createSynthesizedNode(SyntaxKind.ThisKeyword);

}

export function createNull() {

return <NullLiteral & Token<SyntaxKind.NullKeyword>>createSynthesizedNode(SyntaxKind.NullKeyword);

}

export function createTrue() {

return <BooleanLiteral & Token<SyntaxKind.TrueKeyword>>createSynthesizedNode(SyntaxKind.TrueKeyword);

}

export function createFalse() {

return <BooleanLiteral & Token<SyntaxKind.FalseKeyword>>createSynthesizedNode(SyntaxKind.FalseKeyword);

}

// Names

export function createQualifiedName(left: EntityName, right: string | Identifier) {

const node = <QualifiedName>createSynthesizedNode(SyntaxKind.QualifiedName);

node.left = left;

node.right = asName(right);

return node;

}

export function updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier) {

return node.left !== left

|| node.right !== right

? updateNode(createQualifiedName(left, right), node)

: node;

}

export function createComputedPropertyName(expression: Expression) {

const node = <ComputedPropertyName>createSynthesizedNode(SyntaxKind.ComputedPropertyName);

node.expression = expression;

return node;

}

export function updateComputedPropertyName(node: ComputedPropertyName, expression: Expression) {

return node.expression !== expression

? updateNode(createComputedPropertyName(expression), node)

: node;

}

// Signature elements

export function createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.TypeParameter) as TypeParameterDeclaration;

node.name = asName(name);

node.constraint = constraint;

node.default = defaultType;

return node;

}

export function updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined) {

return node.name !== name

|| node.constraint !== constraint

|| node.default !== defaultType

? updateNode(createTypeParameterDeclaration(name, constraint, defaultType), node)

: node;

}

export function createParameter(

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

dotDotDotToken: DotDotDotToken | undefined,

name: string | BindingName,

questionToken?: QuestionToken,

type?: TypeNode,

initializer?: Expression) {

const node = <ParameterDeclaration>createSynthesizedNode(SyntaxKind.Parameter);

node.decorators = asNodeArray(decorators);

node.modifiers = asNodeArray(modifiers);

node.dotDotDotToken = dotDotDotToken;

node.name = asName(name);

node.questionToken = questionToken;

node.type = type;

node.initializer = initializer ? parenthesizeExpressionForList(initializer) : undefined;

return node;

}

export function updateParameter(

node: ParameterDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

dotDotDotToken: DotDotDotToken | undefined,

name: string | BindingName,

questionToken: QuestionToken | undefined,

type: TypeNode | undefined,

initializer: Expression | undefined) {

return node.decorators !== decorators

|| node.modifiers !== modifiers

|| node.dotDotDotToken !== dotDotDotToken

|| node.name !== name

|| node.questionToken !== questionToken

|| node.type !== type

|| node.initializer !== initializer

? updateNode(createParameter(decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer), node)

: node;

}

export function createDecorator(expression: Expression) {

const node = <Decorator>createSynthesizedNode(SyntaxKind.Decorator);

node.expression = parenthesizeForAccess(expression);

return node;

}

export function updateDecorator(node: Decorator, expression: Expression) {

return node.expression !== expression

? updateNode(createDecorator(expression), node)

: node;

}

// Type Elements

export function createPropertySignature(

modifiers: ReadonlyArray<Modifier> | undefined,

name: PropertyName | string,

questionToken: QuestionToken | undefined,

type: TypeNode | undefined,

initializer: Expression | undefined): PropertySignature {

const node = createSynthesizedNode(SyntaxKind.PropertySignature) as PropertySignature;

node.modifiers = asNodeArray(modifiers);

node.name = asName(name);

node.questionToken = questionToken;

node.type = type;

node.initializer = initializer;

return node;

}

export function updatePropertySignature(

node: PropertySignature,

modifiers: ReadonlyArray<Modifier> | undefined,

name: PropertyName,

questionToken: QuestionToken | undefined,

type: TypeNode | undefined,

initializer: Expression | undefined) {

return node.modifiers !== modifiers

|| node.name !== name

|| node.questionToken !== questionToken

|| node.type !== type

|| node.initializer !== initializer

? updateNode(createPropertySignature(modifiers, name, questionToken, type, initializer), node)

: node;

}

export function createProperty(

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

name: string | PropertyName,

questionToken: QuestionToken | undefined,

type: TypeNode | undefined,

initializer: Expression | undefined) {

const node = <PropertyDeclaration>createSynthesizedNode(SyntaxKind.PropertyDeclaration);

node.decorators = asNodeArray(decorators);

node.modifiers = asNodeArray(modifiers);

node.name = asName(name);

node.questionToken = questionToken;

node.type = type;

node.initializer = initializer;

return node;

}

export function updateProperty(

node: PropertyDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

name: string | PropertyName,

questionToken: QuestionToken | undefined,

type: TypeNode | undefined,

initializer: Expression | undefined) {

return node.decorators !== decorators

|| node.modifiers !== modifiers

|| node.name !== name

|| node.questionToken !== questionToken

|| node.type !== type

|| node.initializer !== initializer

? updateNode(createProperty(decorators, modifiers, name, questionToken, type, initializer), node)

: node;

}

export function createMethodSignature(

typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode | undefined,

name: string | PropertyName,

questionToken: QuestionToken | undefined) {

const node = createSignatureDeclaration(SyntaxKind.MethodSignature, typeParameters, parameters, type) as MethodSignature;

node.name = asName(name);

node.questionToken = questionToken;

return node;

}

export function updateMethodSignature(node: MethodSignature, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined) {

return node.typeParameters !== typeParameters

|| node.parameters !== parameters

|| node.type !== type

|| node.name !== name

|| node.questionToken !== questionToken

? updateNode(createMethodSignature(typeParameters, parameters, type, name, questionToken), node)

: node;

}

export function createMethod(

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

asteriskToken: AsteriskToken | undefined,

name: string | PropertyName,

questionToken: QuestionToken | undefined,

typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode | undefined,

body: Block | undefined) {

const node = <MethodDeclaration>createSynthesizedNode(SyntaxKind.MethodDeclaration);

node.decorators = asNodeArray(decorators);

node.modifiers = asNodeArray(modifiers);

node.asteriskToken = asteriskToken;

node.name = asName(name);

node.questionToken = questionToken;

node.typeParameters = asNodeArray(typeParameters);

node.parameters = createNodeArray(parameters);

node.type = type;

node.body = body;

return node;

}

export function updateMethod(

node: MethodDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

asteriskToken: AsteriskToken | undefined,

name: PropertyName,

questionToken: QuestionToken | undefined,

typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode | undefined,

body: Block | undefined) {

return node.decorators !== decorators

|| node.modifiers !== modifiers

|| node.asteriskToken !== asteriskToken

|| node.name !== name

|| node.questionToken !== questionToken

|| node.typeParameters !== typeParameters

|| node.parameters !== parameters

|| node.type !== type

|| node.body !== body

? updateNode(createMethod(decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node)

: node;

}

export function createConstructor(decorators: ReadonlyArray<Decorator> | undefined, modifiers: ReadonlyArray<Modifier> | undefined, parameters: ReadonlyArray<ParameterDeclaration>, body: Block | undefined) {

const node = <ConstructorDeclaration>createSynthesizedNode(SyntaxKind.Constructor);

node.decorators = asNodeArray(decorators);

node.modifiers = asNodeArray(modifiers);

node.typeParameters = undefined;

node.parameters = createNodeArray(parameters);

node.type = undefined;

node.body = body;

return node;

}

export function updateConstructor(

node: ConstructorDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

body: Block | undefined) {

return node.decorators !== decorators

|| node.modifiers !== modifiers

|| node.parameters !== parameters

|| node.body !== body

? updateNode(createConstructor(decorators, modifiers, parameters, body), node)

: node;

}

export function createGetAccessor(

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

name: string | PropertyName,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode | undefined,

body: Block | undefined) {

const node = <GetAccessorDeclaration>createSynthesizedNode(SyntaxKind.GetAccessor);

node.decorators = asNodeArray(decorators);

node.modifiers = asNodeArray(modifiers);

node.name = asName(name);

node.typeParameters = undefined;

node.parameters = createNodeArray(parameters);

node.type = type;

node.body = body;

return node;

}

export function updateGetAccessor(

node: GetAccessorDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

name: PropertyName,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode | undefined,

body: Block | undefined) {

return node.decorators !== decorators

|| node.modifiers !== modifiers

|| node.name !== name

|| node.parameters !== parameters

|| node.type !== type

|| node.body !== body

? updateNode(createGetAccessor(decorators, modifiers, name, parameters, type, body), node)

: node;

}

export function createSetAccessor(

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

name: string | PropertyName,

parameters: ReadonlyArray<ParameterDeclaration>,

body: Block | undefined) {

const node = <SetAccessorDeclaration>createSynthesizedNode(SyntaxKind.SetAccessor);

node.decorators = asNodeArray(decorators);

node.modifiers = asNodeArray(modifiers);

node.name = asName(name);

node.typeParameters = undefined;

node.parameters = createNodeArray(parameters);

node.body = body;

return node;

}

export function updateSetAccessor(

node: SetAccessorDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

name: PropertyName,

parameters: ReadonlyArray<ParameterDeclaration>,

body: Block | undefined) {

return node.decorators !== decorators

|| node.modifiers !== modifiers

|| node.name !== name

|| node.parameters !== parameters

|| node.body !== body

? updateNode(createSetAccessor(decorators, modifiers, name, parameters, body), node)

: node;

}

export function createCallSignature(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) {

return createSignatureDeclaration(SyntaxKind.CallSignature, typeParameters, parameters, type) as CallSignatureDeclaration;

}

export function updateCallSignature(node: CallSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) {

return updateSignatureDeclaration(node, typeParameters, parameters, type);

}

export function createConstructSignature(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) {

return createSignatureDeclaration(SyntaxKind.ConstructSignature, typeParameters, parameters, type) as ConstructSignatureDeclaration;

}

export function updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) {

return updateSignatureDeclaration(node, typeParameters, parameters, type);

}

export function createIndexSignature(

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode): IndexSignatureDeclaration {

const node = createSynthesizedNode(SyntaxKind.IndexSignature) as IndexSignatureDeclaration;

node.decorators = asNodeArray(decorators);

node.modifiers = asNodeArray(modifiers);

node.parameters = createNodeArray(parameters);

node.type = type;

return node;

}

export function updateIndexSignature(

node: IndexSignatureDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode) {

return node.parameters !== parameters

|| node.type !== type

|| node.decorators !== decorators

|| node.modifiers !== modifiers

? updateNode(createIndexSignature(decorators, modifiers, parameters, type), node)

: node;

}

/* @internal */

export function createSignatureDeclaration(kind: SyntaxKind, typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode | undefined) {

const node = createSynthesizedNode(kind) as SignatureDeclaration;

node.typeParameters = asNodeArray(typeParameters);

node.parameters = asNodeArray(parameters);

node.type = type;

return node;

}

function updateSignatureDeclaration<T extends SignatureDeclaration>(node: T, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): T {

return node.typeParameters !== typeParameters

|| node.parameters !== parameters

|| node.type !== type

? updateNode(<T>createSignatureDeclaration(node.kind, typeParameters, parameters, type), node)

: node;

}

// Types

export function createKeywordTypeNode(kind: KeywordTypeNode["kind"]) {

return <KeywordTypeNode>createSynthesizedNode(kind);

}

export function createTypePredicateNode(parameterName: Identifier | ThisTypeNode | string, type: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.TypePredicate) as TypePredicateNode;

node.parameterName = asName(parameterName);

node.type = type;

return node;

}

export function updateTypePredicateNode(node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode) {

return node.parameterName !== parameterName

|| node.type !== type

? updateNode(createTypePredicateNode(parameterName, type), node)

: node;

}

export function createTypeReferenceNode(typeName: string | EntityName, typeArguments: ReadonlyArray<TypeNode> | undefined) {

const node = createSynthesizedNode(SyntaxKind.TypeReference) as TypeReferenceNode;

node.typeName = asName(typeName);

node.typeArguments = typeArguments && parenthesizeTypeParameters(typeArguments);

return node;

}

export function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined) {

return node.typeName !== typeName

|| node.typeArguments !== typeArguments

? updateNode(createTypeReferenceNode(typeName, typeArguments), node)

: node;

}

export function createFunctionTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) {

return createSignatureDeclaration(SyntaxKind.FunctionType, typeParameters, parameters, type) as FunctionTypeNode;

}

export function updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) {

return <FunctionTypeNode>updateSignatureDeclaration(node, typeParameters, parameters, type);

}

export function createConstructorTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined) {

return createSignatureDeclaration(SyntaxKind.ConstructorType, typeParameters, parameters, type) as ConstructorTypeNode;

}

export function updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined) {

return <ConstructorTypeNode>updateSignatureDeclaration(node, typeParameters, parameters, type);

}

export function createTypeQueryNode(exprName: EntityName) {

const node = createSynthesizedNode(SyntaxKind.TypeQuery) as TypeQueryNode;

node.exprName = exprName;

return node;

}

export function updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName) {

return node.exprName !== exprName

? updateNode(createTypeQueryNode(exprName), node)

: node;

}

export function createTypeLiteralNode(members: ReadonlyArray<TypeElement>) {

const node = createSynthesizedNode(SyntaxKind.TypeLiteral) as TypeLiteralNode;

node.members = createNodeArray(members);

return node;

}

export function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray<TypeElement>) {

return node.members !== members

? updateNode(createTypeLiteralNode(members), node)

: node;

}

export function createArrayTypeNode(elementType: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.ArrayType) as ArrayTypeNode;

node.elementType = parenthesizeArrayTypeMember(elementType);

return node;

}

export function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode {

return node.elementType !== elementType

? updateNode(createArrayTypeNode(elementType), node)

: node;

}

export function createTupleTypeNode(elementTypes: ReadonlyArray<TypeNode>) {

const node = createSynthesizedNode(SyntaxKind.TupleType) as TupleTypeNode;

node.elementTypes = createNodeArray(elementTypes);

return node;

}

export function updateTypleTypeNode(node: TupleTypeNode, elementTypes: ReadonlyArray<TypeNode>) {

return node.elementTypes !== elementTypes

? updateNode(createTupleTypeNode(elementTypes), node)

: node;

}

export function createUnionTypeNode(types: TypeNode[]): UnionTypeNode {

return <UnionTypeNode>createUnionOrIntersectionTypeNode(SyntaxKind.UnionType, types);

}

export function updateUnionTypeNode(node: UnionTypeNode, types: NodeArray<TypeNode>) {

return updateUnionOrIntersectionTypeNode(node, types);

}

export function createIntersectionTypeNode(types: TypeNode[]): IntersectionTypeNode {

return <IntersectionTypeNode>createUnionOrIntersectionTypeNode(SyntaxKind.IntersectionType, types);

}

export function updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray<TypeNode>) {

return updateUnionOrIntersectionTypeNode(node, types);

}

export function createUnionOrIntersectionTypeNode(kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType, types: ReadonlyArray<TypeNode>) {

const node = createSynthesizedNode(kind) as UnionTypeNode | IntersectionTypeNode;

node.types = parenthesizeElementTypeMembers(types);

return node;

}

function updateUnionOrIntersectionTypeNode<T extends UnionOrIntersectionTypeNode>(node: T, types: NodeArray<TypeNode>): T {

return node.types !== types

? updateNode(<T>createUnionOrIntersectionTypeNode(node.kind, types), node)

: node;

}

export function createParenthesizedType(type: TypeNode) {

const node = <ParenthesizedTypeNode>createSynthesizedNode(SyntaxKind.ParenthesizedType);

node.type = type;

return node;

}

export function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode) {

return node.type !== type

? updateNode(createParenthesizedType(type), node)

: node;

}

export function createThisTypeNode() {

return <ThisTypeNode>createSynthesizedNode(SyntaxKind.ThisType);

}

export function createTypeOperatorNode(type: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.TypeOperator) as TypeOperatorNode;

node.operator = SyntaxKind.KeyOfKeyword;

node.type = parenthesizeElementTypeMember(type);

return node;

}

export function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode) {

return node.type !== type ? updateNode(createTypeOperatorNode(type), node) : node;

}

export function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.IndexedAccessType) as IndexedAccessTypeNode;

node.objectType = parenthesizeElementTypeMember(objectType);

node.indexType = indexType;

return node;

}

export function updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode) {

return node.objectType !== objectType

|| node.indexType !== indexType

? updateNode(createIndexedAccessTypeNode(objectType, indexType), node)

: node;

}

export function createMappedTypeNode(readonlyToken: ReadonlyToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | undefined, type: TypeNode | undefined): MappedTypeNode {

const node = createSynthesizedNode(SyntaxKind.MappedType) as MappedTypeNode;

node.readonlyToken = readonlyToken;

node.typeParameter = typeParameter;

node.questionToken = questionToken;

node.type = type;

return node;

}

export function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | undefined, type: TypeNode | undefined): MappedTypeNode {

return node.readonlyToken !== readonlyToken

|| node.typeParameter !== typeParameter

|| node.questionToken !== questionToken

|| node.type !== type

? updateNode(createMappedTypeNode(readonlyToken, typeParameter, questionToken, type), node)

: node;

}

export function createLiteralTypeNode(literal: LiteralTypeNode["literal"]) {

const node = createSynthesizedNode(SyntaxKind.LiteralType) as LiteralTypeNode;

node.literal = literal;

return node;

}

export function updateLiteralTypeNode(node: LiteralTypeNode, literal: LiteralTypeNode["literal"]) {

return node.literal !== literal

? updateNode(createLiteralTypeNode(literal), node)

: node;

}

// Binding Patterns

export function createObjectBindingPattern(elements: ReadonlyArray<BindingElement>) {

const node = <ObjectBindingPattern>createSynthesizedNode(SyntaxKind.ObjectBindingPattern);

node.elements = createNodeArray(elements);

return node;

}

export function updateObjectBindingPattern(node: ObjectBindingPattern, elements: ReadonlyArray<BindingElement>) {

return node.elements !== elements

? updateNode(createObjectBindingPattern(elements), node)

: node;

}

export function createArrayBindingPattern(elements: ReadonlyArray<ArrayBindingElement>) {

const node = <ArrayBindingPattern>createSynthesizedNode(SyntaxKind.ArrayBindingPattern);

node.elements = createNodeArray(elements);

return node;

}

export function updateArrayBindingPattern(node: ArrayBindingPattern, elements: ReadonlyArray<ArrayBindingElement>) {

return node.elements !== elements

? updateNode(createArrayBindingPattern(elements), node)

: node;

}

export function createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression) {

const node = <BindingElement>createSynthesizedNode(SyntaxKind.BindingElement);

node.dotDotDotToken = dotDotDotToken;

node.propertyName = asName(propertyName);

node.name = asName(name);

node.initializer = initializer;

return node;

}

export function updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined) {

return node.propertyName !== propertyName

|| node.dotDotDotToken !== dotDotDotToken

|| node.name !== name

|| node.initializer !== initializer

? updateNode(createBindingElement(dotDotDotToken, propertyName, name, initializer), node)

: node;

}

// Expression

export function createArrayLiteral(elements?: ReadonlyArray<Expression>, multiLine?: boolean) {

const node = <ArrayLiteralExpression>createSynthesizedNode(SyntaxKind.ArrayLiteralExpression);

node.elements = parenthesizeListElements(createNodeArray(elements));

if (multiLine) node.multiLine = true;

return node;

}

export function updateArrayLiteral(node: ArrayLiteralExpression, elements: ReadonlyArray<Expression>) {

return node.elements !== elements

? updateNode(createArrayLiteral(elements, node.multiLine), node)

: node;

}

export function createObjectLiteral(properties?: ReadonlyArray<ObjectLiteralElementLike>, multiLine?: boolean) {

const node = <ObjectLiteralExpression>createSynthesizedNode(SyntaxKind.ObjectLiteralExpression);

node.properties = createNodeArray(properties);

if (multiLine) node.multiLine = true;

return node;

}

export function updateObjectLiteral(node: ObjectLiteralExpression, properties: ReadonlyArray<ObjectLiteralElementLike>) {

return node.properties !== properties

? updateNode(createObjectLiteral(properties, node.multiLine), node)

: node;

}

export function createPropertyAccess(expression: Expression, name: string | Identifier) {

const node = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);

node.expression = parenthesizeForAccess(expression);

node.name = asName(name);

setEmitFlags(node, EmitFlags.NoIndentation);

return node;

}

export function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier) {

// Because we are updating existed propertyAccess we want to inherit its emitFlags

// instead of using the default from createPropertyAccess

return node.expression !== expression

|| node.name !== name

? updateNode(setEmitFlags(createPropertyAccess(expression, name), getEmitFlags(node)), node)

: node;

}

export function createElementAccess(expression: Expression, index: number | Expression) {

const node = <ElementAccessExpression>createSynthesizedNode(SyntaxKind.ElementAccessExpression);

node.expression = parenthesizeForAccess(expression);

node.argumentExpression = asExpression(index);

return node;

}

export function updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression) {

return node.expression !== expression

|| node.argumentExpression !== argumentExpression

? updateNode(createElementAccess(expression, argumentExpression), node)

: node;

}

export function createCall(expression: Expression, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentsArray: ReadonlyArray<Expression>) {

const node = <CallExpression>createSynthesizedNode(SyntaxKind.CallExpression);

node.expression = parenthesizeForAccess(expression);

node.typeArguments = asNodeArray(typeArguments);

node.arguments = parenthesizeListElements(createNodeArray(argumentsArray));

return node;

}

export function updateCall(node: CallExpression, expression: Expression, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentsArray: ReadonlyArray<Expression>) {

return node.expression !== expression

|| node.typeArguments !== typeArguments

|| node.arguments !== argumentsArray

? updateNode(createCall(expression, typeArguments, argumentsArray), node)

: node;

}

export function createNew(expression: Expression, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentsArray: ReadonlyArray<Expression> | undefined) {

const node = <NewExpression>createSynthesizedNode(SyntaxKind.NewExpression);

node.expression = parenthesizeForNew(expression);

node.typeArguments = asNodeArray(typeArguments);

node.arguments = argumentsArray ? parenthesizeListElements(createNodeArray(argumentsArray)) : undefined;

return node;

}

export function updateNew(node: NewExpression, expression: Expression, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentsArray: ReadonlyArray<Expression> | undefined) {

return node.expression !== expression

|| node.typeArguments !== typeArguments

|| node.arguments !== argumentsArray

? updateNode(createNew(expression, typeArguments, argumentsArray), node)

: node;

}

export function createTaggedTemplate(tag: Expression, template: TemplateLiteral) {

const node = <TaggedTemplateExpression>createSynthesizedNode(SyntaxKind.TaggedTemplateExpression);

node.tag = parenthesizeForAccess(tag);

node.template = template;

return node;

}

export function updateTaggedTemplate(node: TaggedTemplateExpression, tag: Expression, template: TemplateLiteral) {

return node.tag !== tag

|| node.template !== template

? updateNode(createTaggedTemplate(tag, template), node)

: node;

}

export function createTypeAssertion(type: TypeNode, expression: Expression) {

const node = <TypeAssertion>createSynthesizedNode(SyntaxKind.TypeAssertionExpression);

node.type = type;

node.expression = parenthesizePrefixOperand(expression);

return node;

}

export function updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression) {

return node.type !== type

|| node.expression !== expression

? updateNode(createTypeAssertion(type, expression), node)

: node;

}

export function createParen(expression: Expression) {

const node = <ParenthesizedExpression>createSynthesizedNode(SyntaxKind.ParenthesizedExpression);

node.expression = expression;

return node;

}

export function updateParen(node: ParenthesizedExpression, expression: Expression) {

return node.expression !== expression

? updateNode(createParen(expression), node)

: node;

}

export function createFunctionExpression(

modifiers: ReadonlyArray<Modifier> | undefined,

asteriskToken: AsteriskToken | undefined,

name: string | Identifier | undefined,

typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode | undefined,

body: Block) {

const node = <FunctionExpression>createSynthesizedNode(SyntaxKind.FunctionExpression);

node.modifiers = asNodeArray(modifiers);

node.asteriskToken = asteriskToken;

node.name = asName(name);

node.typeParameters = asNodeArray(typeParameters);

node.parameters = createNodeArray(parameters);

node.type = type;

node.body = body;

return node;

}

export function updateFunctionExpression(

node: FunctionExpression,

modifiers: ReadonlyArray<Modifier> | undefined,

asteriskToken: AsteriskToken | undefined,

name: Identifier | undefined,

typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined,

parameters: ReadonlyArray<ParameterDeclaration>,

type: TypeNode | undefined,

body: Block) {

return node.name !== name

|| node.modifiers !== modifiers

|| node.asteriskToken !== asteriskToken

|| node.typeParameters !== typeParameters

|| node.parameters !== parameters