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

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 || elements === emptyArray) {

elements = [];

}

else if (isNodeArray(elements)) {

return 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): T {

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

}

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

/* @internal */ export function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier, isSingleQuote: boolean): StringLiteral; // tslint:disable-line unified-signatures

/** If a node is passed, creates a string literal whose source text is read from a source node during emit. */

export function createLiteral(value: string | StringLiteral | NoSubstitutionTemplateLiteral | NumericLiteral | Identifier): StringLiteral;

export function createLiteral(value: number): NumericLiteral;

export function createLiteral(value: boolean): BooleanLiteral;

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

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

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

return createNumericLiteral(value + "");

}

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

return value ? createTrue() : createFalse();

}

if (isString(value)) {

const res = createStringLiteral(value);

if (isSingleQuote) res.singleQuote = true;

return res;

}

return createLiteralFromNode(value);

}

export function createNumericLiteral(value: string): NumericLiteral {

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

node.text = value;

node.numericLiteralFlags = 0;

return node;

}

export function createStringLiteral(text: string): StringLiteral {

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

node.text = text;

return node;

}

export function createRegularExpressionLiteral(text: string): RegularExpressionLiteral {

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

node.text = text;

return node;

}

function createLiteralFromNode(sourceNode: PropertyNameLiteral): 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 | TypeParameterDeclaration> | undefined): Identifier; // tslint:disable-line unified-signatures

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

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

node.escapedText = escapeLeadingUnderscores(text);

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

node.autoGenerateFlags = GeneratedIdentifierFlags.None;

node.autoGenerateId = 0;

if (typeArguments) {

node.typeArguments = createNodeArray(typeArguments as ReadonlyArray<TypeNode>);

}

return node;

}

export function updateIdentifier(node: Identifier): Identifier;

/* @internal */

export function updateIdentifier(node: Identifier, typeArguments: NodeArray<TypeNode | TypeParameterDeclaration> | undefined): Identifier; // tslint:disable-line unified-signatures

export function updateIdentifier(node: Identifier, typeArguments?: NodeArray<TypeNode | TypeParameterDeclaration> | 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;

/* @internal */ export function createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes: boolean): GeneratedIdentifier; // tslint:disable-line unified-signatures

export function createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined, reservedInNestedScopes?: boolean): GeneratedIdentifier {

const name = createIdentifier("") as GeneratedIdentifier;

name.autoGenerateFlags = GeneratedIdentifierFlags.Auto;

name.autoGenerateId = nextAutoGenerateId;

nextAutoGenerateId++;

if (recordTempVariable) {

recordTempVariable(name);

}

if (reservedInNestedScopes) {

name.autoGenerateFlags |= GeneratedIdentifierFlags.ReservedInNestedScopes;

}

return name;

}

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

export function createLoopVariable(): Identifier {

const name = createIdentifier("");

name.autoGenerateFlags = GeneratedIdentifierFlags.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.autoGenerateFlags = GeneratedIdentifierFlags.Unique;

name.autoGenerateId = nextAutoGenerateId;

nextAutoGenerateId++;

return name;

}

/* @internal */ export function createOptimisticUniqueName(text: string): GeneratedIdentifier;

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

export function createOptimisticUniqueName(text: string): Identifier;

export function createOptimisticUniqueName(text: string): GeneratedIdentifier {

const name = createIdentifier(text) as GeneratedIdentifier;

name.autoGenerateFlags = GeneratedIdentifierFlags.Unique | GeneratedIdentifierFlags.Optimistic;

name.autoGenerateId = nextAutoGenerateId;

nextAutoGenerateId++;

return name;

}

/** Create a unique name based on the supplied text. This does not consider names injected by the transformer. */

export function createFileLevelUniqueName(text: string): Identifier {

const name = createOptimisticUniqueName(text);

name.autoGenerateFlags |= GeneratedIdentifierFlags.FileLevel;

return name;

}

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

export function getGeneratedNameForNode(node: Node | undefined): Identifier;

/* @internal */ export function getGeneratedNameForNode(node: Node | undefined, flags: GeneratedIdentifierFlags): Identifier; // tslint:disable-line unified-signatures

export function getGeneratedNameForNode(node: Node | undefined, flags?: GeneratedIdentifierFlags): Identifier {

const name = createIdentifier(node && isIdentifier(node) ? idText(node) : "");

name.autoGenerateFlags = GeneratedIdentifierFlags.Node | flags!;

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

}

// Modifiers

export function createModifier<T extends Modifier["kind"]>(kind: T) {

return createToken(kind);

}

export function createModifiersFromModifierFlags(flags: ModifierFlags) {

const result: Modifier[] = [];

if (flags & ModifierFlags.Export) { result.push(createModifier(SyntaxKind.ExportKeyword)); }

if (flags & ModifierFlags.Ambient) { result.push(createModifier(SyntaxKind.DeclareKeyword)); }

if (flags & ModifierFlags.Default) { result.push(createModifier(SyntaxKind.DefaultKeyword)); }

if (flags & ModifierFlags.Const) { result.push(createModifier(SyntaxKind.ConstKeyword)); }

if (flags & ModifierFlags.Public) { result.push(createModifier(SyntaxKind.PublicKeyword)); }

if (flags & ModifierFlags.Private) { result.push(createModifier(SyntaxKind.PrivateKeyword)); }

if (flags & ModifierFlags.Protected) { result.push(createModifier(SyntaxKind.ProtectedKeyword)); }

if (flags & ModifierFlags.Abstract) { result.push(createModifier(SyntaxKind.AbstractKeyword)); }

if (flags & ModifierFlags.Static) { result.push(createModifier(SyntaxKind.StaticKeyword)); }

if (flags & ModifierFlags.Readonly) { result.push(createModifier(SyntaxKind.ReadonlyKeyword)); }

if (flags & ModifierFlags.Async) { result.push(createModifier(SyntaxKind.AsyncKeyword)); }

return result;

}

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

}

function parenthesizeForComputedName(expression: Expression): Expression {

return isCommaSequence(expression)

? createParen(expression)

: expression;

}

export function createComputedPropertyName(expression: Expression) {

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

node.expression = parenthesizeForComputedName(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,

questionOrExclamationToken: QuestionToken | ExclamationToken | 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 = questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === SyntaxKind.QuestionToken ? questionOrExclamationToken : undefined;

node.exclamationToken = questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === SyntaxKind.ExclamationToken ? questionOrExclamationToken : undefined;

node.type = type;

node.initializer = initializer;

return node;

}

export function updateProperty(

node: PropertyDeclaration,

decorators: ReadonlyArray<Decorator> | undefined,

modifiers: ReadonlyArray<Modifier> | undefined,

name: string | PropertyName,

questionOrExclamationToken: QuestionToken | ExclamationToken | undefined,

type: TypeNode | undefined,

initializer: Expression | undefined) {

return node.decorators !== decorators

|| node.modifiers !== modifiers

|| node.name !== name

|| node.questionToken !== (questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === SyntaxKind.QuestionToken ? questionOrExclamationToken : undefined)

|| node.exclamationToken !== (questionOrExclamationToken !== undefined && questionOrExclamationToken.kind === SyntaxKind.ExclamationToken ? questionOrExclamationToken : undefined)

|| node.type !== type

|| node.initializer !== initializer

? updateNode(createProperty(decorators, modifiers, name, questionOrExclamationToken, 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: ReadonlyArray<TypeParameterDeclaration> | undefined, parameters: ReadonlyArray<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: ReadonlyArray<TypeParameterDeclaration> | undefined, parameters: ReadonlyArray<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, typeArguments?: ReadonlyArray<TypeNode> | undefined) {

const node = createSynthesizedNode(kind) as SignatureDeclaration;

node.typeParameters = asNodeArray(typeParameters);

node.parameters = asNodeArray(parameters);

node.type = type;

node.typeArguments = asNodeArray(typeArguments);

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: ReadonlyArray<TypeParameterDeclaration> | undefined, parameters: ReadonlyArray<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 updateSignatureDeclaration(node, typeParameters, parameters, type);

}

export function createConstructorTypeNode(typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined, parameters: ReadonlyArray<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 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> | undefined) {

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 updateTupleTypeNode(node: TupleTypeNode, elementTypes: ReadonlyArray<TypeNode>) {

return node.elementTypes !== elementTypes

? updateNode(createTupleTypeNode(elementTypes), node)

: node;

}

export function createOptionalTypeNode(type: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.OptionalType) as OptionalTypeNode;

node.type = parenthesizeArrayTypeMember(type);

return node;

}

export function updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode {

return node.type !== type

? updateNode(createOptionalTypeNode(type), node)

: node;

}

export function createRestTypeNode(type: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.RestType) as RestTypeNode;

node.type = type;

return node;

}

export function updateRestTypeNode(node: RestTypeNode, type: TypeNode): RestTypeNode {

return node.type !== type

? updateNode(createRestTypeNode(type), node)

: node;

}

export function createUnionTypeNode(types: ReadonlyArray<TypeNode>): UnionTypeNode {

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

}

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

return updateUnionOrIntersectionTypeNode(node, types);

}

export function createIntersectionTypeNode(types: ReadonlyArray<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 createConditionalTypeNode(checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) {

const node = createSynthesizedNode(SyntaxKind.ConditionalType) as ConditionalTypeNode;

node.checkType = parenthesizeConditionalTypeMember(checkType);

node.extendsType = parenthesizeConditionalTypeMember(extendsType);

node.trueType = trueType;

node.falseType = falseType;

return node;

}

export function updateConditionalTypeNode(node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) {

return node.checkType !== checkType

|| node.extendsType !== extendsType

|| node.trueType !== trueType

|| node.falseType !== falseType

? updateNode(createConditionalTypeNode(checkType, extendsType, trueType, falseType), node)

: node;

}

export function createInferTypeNode(typeParameter: TypeParameterDeclaration) {

const node = <InferTypeNode>createSynthesizedNode(SyntaxKind.InferType);

node.typeParameter = typeParameter;

return node;

}

export function updateInferTypeNode(node: InferTypeNode, typeParameter: TypeParameterDeclaration) {

return node.typeParameter !== typeParameter

? updateNode(createInferTypeNode(typeParameter), node)

: node;

}

export function createImportTypeNode(argument: TypeNode, qualifier?: EntityName, typeArguments?: ReadonlyArray<TypeNode>, isTypeOf?: boolean) {

const node = <ImportTypeNode>createSynthesizedNode(SyntaxKind.ImportType);

node.argument = argument;

node.qualifier = qualifier;

node.typeArguments = asNodeArray(typeArguments);

node.isTypeOf = isTypeOf;

return node;

}

export function updateImportTypeNode(node: ImportTypeNode, argument: TypeNode, qualifier?: EntityName, typeArguments?: ReadonlyArray<TypeNode>, isTypeOf?: boolean) {

return node.argument !== argument

|| node.qualifier !== qualifier

|| node.typeArguments !== typeArguments

|| node.isTypeOf !== isTypeOf

? updateNode(createImportTypeNode(argument, qualifier, typeArguments, isTypeOf), 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): TypeOperatorNode;

export function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword, type: TypeNode): TypeOperatorNode;

export function createTypeOperatorNode(operatorOrType: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | TypeNode, type?: TypeNode) {

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

node.operator = typeof operatorOrType === "number" ? operatorOrType : SyntaxKind.KeyOfKeyword;

node.type = parenthesizeElementTypeMember(typeof operatorOrType === "number" ? type! : operatorOrType);

return node;

}

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

return node.type !== type ? updateNode(createTypeOperatorNode(node.operator, 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 | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | 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 | PlusToken | MinusToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | PlusToken | MinusToken | 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 | undefined) {

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

node.expression = parenthesizeForAccess(expression);