import {

addToSeen,

ArrowFunction,

BindingElement,

CharacterCodes,

ClassElement,

ClassExpression,

ClassLikeDeclaration,

CommentRange,

concatenate,

ConstructorDeclaration,

contains,

createMultiMap,

createNodeFactory,

createPrinter,

createRange,

createSourceFile,

createTextChange,

createTextRangeFromSpan,

createTextSpan,

createTextSpanFromRange,

createTextWriter,

Debug,

DeclarationStatement,

EmitHint,

EmitTextWriter,

endsWith,

EnumDeclaration,

EnumMember,

Expression,

factory,

FileTextChanges,

filter,

find,

findChildOfKind,

findLastIndex,

findNextToken,

findPrecedingToken,

first,

firstOrUndefined,

flatMap,

flatMapToMutable,

formatting,

FunctionDeclaration,

FunctionExpression,

getAncestor,

getFirstNonSpaceCharacterPosition,

getFormatCodeSettingsForWriting,

getJSDocCommentRanges,

getLeadingCommentRanges,

getLineAndCharacterOfPosition,

getLineOfLocalPosition,

getLineStartPositionForPosition,

getNewLineKind,

getNewLineOrDefaultFromHost,

getNodeId,

getOriginalNode,

getPrecedingNonSpaceCharacterPosition,

getScriptKindFromFileName,

getShebang,

getSourceFileOfNode,

getStartPositionOfLine,

getTokenAtPosition,

getTouchingToken,

getTrailingCommentRanges,

group,

HasJSDoc,

hasJSDocNodes,

ImportClause,

ImportSpecifier,

indexOfNode,

InterfaceDeclaration,

intersperse,

isAnyImportSyntax,

isArray,

isArrowFunction,

isCallExpression,

isClassElement,

isClassOrTypeElement,

isExpressionStatement,

isFunctionDeclaration,

isFunctionExpression,

isFunctionLike,

isIdentifier,

isImportClause,

isImportDeclaration,

isImportSpecifier,

isInComment,

isInJSXText,

isInString,

isInTemplateString,

isInterfaceDeclaration,

isJsonSourceFile,

isLineBreak,

isNamedImports,

isObjectLiteralExpression,

isParameter,

isPinnedComment,

isPrologueDirective,

isPropertyDeclaration,

isPropertySignature,

isRecognizedTripleSlashComment,

isStatement,

isStatementButNotDeclaration,

isString,

isStringLiteral,

isSuperCall,

isVariableDeclaration,

isWhiteSpaceLike,

isWhiteSpaceSingleLine,

JSDoc,

JSDocComment,

JSDocParameterTag,

JSDocParsingMode,

JSDocReturnTag,

JSDocTag,

JSDocTypeTag,

LanguageServiceHost,

last,

lastOrUndefined,

length,

mapDefined,

MethodSignature,

Modifier,

MultiMap,

NamedImportBindings,

NamedImports,

NamespaceImport,

Node,

NodeArray,

NodeFactoryFlags,

nodeIsSynthesized,

nullTransformationContext,

ObjectLiteralElementLike,

ObjectLiteralExpression,

ParameterDeclaration,

positionsAreOnSameLine,

PrintHandlers,

PrologueDirective,

PropertyAssignment,

PropertyDeclaration,

PropertySignature,

rangeContainsPosition,

rangeContainsRangeExclusive,

rangeOfNode,

rangeOfTypeParameters,

rangeStartPositionsAreOnSameLine,

removeSuffix,

ScriptKind,

ScriptTarget,

setTextRangePosEnd,

SignatureDeclaration,

singleOrUndefined,

skipTrivia,

SourceFile,

SourceFileLike,

stableSort,

Statement,

stringContainsAt,

Symbol,

SyntaxKind,

TextChange,

TextRange,

textSpanEnd,

Token,

tokenToString,

TransformationContext,

TypeLiteralNode,

TypeNode,

TypeParameterDeclaration,

UserPreferences,

VariableDeclaration,

VariableStatement,

visitEachChild,

visitNodes,

Visitor,

} from "./_namespaces/ts.js";

/**

* Currently for simplicity we store recovered positions on the node itself.

* It can be changed to side-table later if we decide that current design is too invasive.

*/

function getPos(n: TextRange): number {

const result = (n as any).__pos;

Debug.assert(typeof result === "number");

return result;

}

function setPos(n: TextRange, pos: number): void {

Debug.assert(typeof pos === "number");

(n as any).__pos = pos;

}

function getEnd(n: TextRange): number {

const result = (n as any).__end;

Debug.assert(typeof result === "number");

return result;

}

function setEnd(n: TextRange, end: number): void {

Debug.assert(typeof end === "number");

(n as any).__end = end;

}

/** @internal */

export interface ConfigurableStart {

leadingTriviaOption?: LeadingTriviaOption;

}

/** @internal */

export interface ConfigurableEnd {

trailingTriviaOption?: TrailingTriviaOption;

}

/** @internal */

export enum LeadingTriviaOption {

/** Exclude all leading trivia (use getStart()) */

Exclude,

/** Include leading trivia and,

* if there are no line breaks between the node and the previous token,

* include all trivia between the node and the previous token

*/

IncludeAll,

/**

* Include attached JSDoc comments

*/

JSDoc,

/**

* Only delete trivia on the same line as getStart().

* Used to avoid deleting leading comments

*/

StartLine,

}

/** @internal */

export enum TrailingTriviaOption {

/** Exclude all trailing trivia (use getEnd()) */

Exclude,

/** Doesn't include whitespace, but does strip comments */

ExcludeWhitespace,

/** Include trailing trivia */

Include,

}

function skipWhitespacesAndLineBreaks(text: string, start: number) {

return skipTrivia(text, start, /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);

}

function hasCommentsBeforeLineBreak(text: string, start: number) {

let i = start;

while (i < text.length) {

const ch = text.charCodeAt(i);

if (isWhiteSpaceSingleLine(ch)) {

i++;

continue;

}

return ch === CharacterCodes.slash;

}

return false;

}

/**

* Usually node.pos points to a position immediately after the previous token.

* If this position is used as a beginning of the span to remove - it might lead to removing the trailing trivia of the previous node, i.e:

* const x; // this is x

* ^ - pos for the next variable declaration will point here

* const y; // this is y

* ^ - end for previous variable declaration

* Usually leading trivia of the variable declaration 'y' should not include trailing trivia (whitespace, comment 'this is x' and newline) from the preceding

* variable declaration and trailing trivia for 'y' should include (whitespace, comment 'this is y', newline).

* By default when removing nodes we adjust start and end positions to respect specification of the trivia above.

* If pos\end should be interpreted literally (that is, withouth including leading and trailing trivia), `leadingTriviaOption` should be set to `LeadingTriviaOption.Exclude`

* and `trailingTriviaOption` to `TrailingTriviaOption.Exclude`.

*

* @internal

*/

export interface ConfigurableStartEnd extends ConfigurableStart, ConfigurableEnd {}

const useNonAdjustedPositions: ConfigurableStartEnd = {

leadingTriviaOption: LeadingTriviaOption.Exclude,

trailingTriviaOption: TrailingTriviaOption.Exclude,

};

/** @internal */

export interface InsertNodeOptions {

/**

* Text to be inserted before the new node

*/

prefix?: string;

/**

* Text to be inserted after the new node

*/

suffix?: string;

/**

* Text of inserted node will be formatted with this indentation, otherwise indentation will be inferred from the old node

*/

indentation?: number;

/**

* Text of inserted node will be formatted with this delta, otherwise delta will be inferred from the new node kind

*/

delta?: number;

}

/** @internal */

export interface ReplaceWithMultipleNodesOptions extends InsertNodeOptions {

readonly joiner?: string;

}

enum ChangeKind {

Remove,

ReplaceWithSingleNode,

ReplaceWithMultipleNodes,

Text,

}

type Change = ReplaceWithSingleNode | ReplaceWithMultipleNodes | RemoveNode | ChangeText;

interface BaseChange {

readonly sourceFile: SourceFile;

readonly range: TextRange;

}

/** @internal */

export interface ChangeNodeOptions extends ConfigurableStartEnd, InsertNodeOptions {}

interface ReplaceWithSingleNode extends BaseChange {

readonly kind: ChangeKind.ReplaceWithSingleNode;

readonly node: Node;

readonly options?: InsertNodeOptions;

}

interface RemoveNode extends BaseChange {

readonly kind: ChangeKind.Remove;

readonly node?: never;

readonly options?: never;

}

interface ReplaceWithMultipleNodes extends BaseChange {

readonly kind: ChangeKind.ReplaceWithMultipleNodes;

readonly nodes: readonly Node[];

readonly options?: ReplaceWithMultipleNodesOptions;

}

interface ChangeText extends BaseChange {

readonly kind: ChangeKind.Text;

readonly text: string;

}

interface NewFileInsertion {

readonly oldFile?: SourceFile;

readonly statements: readonly (Statement | SyntaxKind.NewLineTrivia)[];

}

function getAdjustedRange(sourceFile: SourceFile, startNode: Node, endNode: Node, options: ConfigurableStartEnd): TextRange {

return { pos: getAdjustedStartPosition(sourceFile, startNode, options), end: getAdjustedEndPosition(sourceFile, endNode, options) };

}

function getAdjustedStartPosition(sourceFile: SourceFile, node: Node, options: ConfigurableStartEnd, hasTrailingComment = false) {

const { leadingTriviaOption } = options;

if (leadingTriviaOption === LeadingTriviaOption.Exclude) {

return node.getStart(sourceFile);

}

if (leadingTriviaOption === LeadingTriviaOption.StartLine) {

const startPos = node.getStart(sourceFile);

const pos = getLineStartPositionForPosition(startPos, sourceFile);

return rangeContainsPosition(node, pos) ? pos : startPos;

}

if (leadingTriviaOption === LeadingTriviaOption.JSDoc) {

const JSDocComments = getJSDocCommentRanges(node, sourceFile.text);

if (JSDocComments?.length) {

return getLineStartPositionForPosition(JSDocComments[0].pos, sourceFile);

}

}

const fullStart = node.getFullStart();

const start = node.getStart(sourceFile);

if (fullStart === start) {

return start;

}

const fullStartLine = getLineStartPositionForPosition(fullStart, sourceFile);

const startLine = getLineStartPositionForPosition(start, sourceFile);

if (startLine === fullStartLine) {

// full start and start of the node are on the same line

// a, b;

// ^ ^

// | start

// fullstart

// when b is replaced - we usually want to keep the leading trvia

// when b is deleted - we delete it

return leadingTriviaOption === LeadingTriviaOption.IncludeAll ? fullStart : start;

}

// if node has a trailing comments, use comment end position as the text has already been included.

if (hasTrailingComment) {

// Check first for leading comments as if the node is the first import, we want to exclude the trivia;

// otherwise we get the trailing comments.

const comment = getLeadingCommentRanges(sourceFile.text, fullStart)?.[0] || getTrailingCommentRanges(sourceFile.text, fullStart)?.[0];

if (comment) {

return skipTrivia(sourceFile.text, comment.end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);

}

}

// get start position of the line following the line that contains fullstart position

// (but only if the fullstart isn't the very beginning of the file)

const nextLineStart = fullStart > 0 ? 1 : 0;

let adjustedStartPosition = getStartPositionOfLine(getLineOfLocalPosition(sourceFile, fullStartLine) + nextLineStart, sourceFile);

// skip whitespaces/newlines

adjustedStartPosition = skipWhitespacesAndLineBreaks(sourceFile.text, adjustedStartPosition);

return getStartPositionOfLine(getLineOfLocalPosition(sourceFile, adjustedStartPosition), sourceFile);

}

/** Return the end position of a multiline comment of it is on another line; otherwise returns `undefined`; */

function getEndPositionOfMultilineTrailingComment(sourceFile: SourceFile, node: Node, options: ConfigurableEnd): number | undefined {

const { end } = node;

const { trailingTriviaOption } = options;

if (trailingTriviaOption === TrailingTriviaOption.Include) {

// If the trailing comment is a multiline comment that extends to the next lines,

// return the end of the comment and track it for the next nodes to adjust.

const comments = getTrailingCommentRanges(sourceFile.text, end);

if (comments) {

const nodeEndLine = getLineOfLocalPosition(sourceFile, node.end);

for (const comment of comments) {

// Single line can break the loop as trivia will only be this line.

// Comments on subsequest lines are also ignored.

if (comment.kind === SyntaxKind.SingleLineCommentTrivia || getLineOfLocalPosition(sourceFile, comment.pos) > nodeEndLine) {

break;

}

// Get the end line of the comment and compare against the end line of the node.

// If the comment end line position and the multiline comment extends to multiple lines,

// then is safe to return the end position.

const commentEndLine = getLineOfLocalPosition(sourceFile, comment.end);

if (commentEndLine > nodeEndLine) {

return skipTrivia(sourceFile.text, comment.end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ true);

}

}

}

}

return undefined;

}

function getAdjustedEndPosition(sourceFile: SourceFile, node: Node, options: ConfigurableEnd): number {

const { end } = node;

const { trailingTriviaOption } = options;

if (trailingTriviaOption === TrailingTriviaOption.Exclude) {

return end;

}

if (trailingTriviaOption === TrailingTriviaOption.ExcludeWhitespace) {

const comments = concatenate(getTrailingCommentRanges(sourceFile.text, end), getLeadingCommentRanges(sourceFile.text, end));

const realEnd = comments?.[comments.length - 1]?.end;

if (realEnd) {

return realEnd;

}

return end;

}

const multilineEndPosition = getEndPositionOfMultilineTrailingComment(sourceFile, node, options);

if (multilineEndPosition) {

return multilineEndPosition;

}

const newEnd = skipTrivia(sourceFile.text, end, /*stopAfterLineBreak*/ true);

return newEnd !== end && (trailingTriviaOption === TrailingTriviaOption.Include || isLineBreak(sourceFile.text.charCodeAt(newEnd - 1)))

? newEnd

: end;

}

/**

* Checks if 'candidate' argument is a legal separator in the list that contains 'node' as an element

*/

function isSeparator(node: Node, candidate: Node | undefined): candidate is Token<SyntaxKind.CommaToken | SyntaxKind.SemicolonToken> {

return !!candidate && !!node.parent && (candidate.kind === SyntaxKind.CommaToken || (candidate.kind === SyntaxKind.SemicolonToken && node.parent.kind === SyntaxKind.ObjectLiteralExpression));

}

/** @internal */

export interface TextChangesContext {

host: LanguageServiceHost;

formatContext: formatting.FormatContext;

preferences: UserPreferences;

}

/** @internal */

export type TypeAnnotatable = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertyDeclaration | PropertySignature;

/** @internal */

export type ThisTypeAnnotatable = FunctionDeclaration | FunctionExpression;

/** @internal */

export function isThisTypeAnnotatable(containingFunction: SignatureDeclaration): containingFunction is ThisTypeAnnotatable {

return isFunctionExpression(containingFunction) || isFunctionDeclaration(containingFunction);

}

/** @internal */

export class ChangeTracker {

private readonly changes: Change[] = [];

private newFileChanges?: MultiMap<string, NewFileInsertion>;

private readonly classesWithNodesInsertedAtStart = new Map<number, { readonly node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression; readonly sourceFile: SourceFile; }>(); // Set<ClassDeclaration> implemented as Map<node id, ClassDeclaration>

private readonly deletedNodes: { readonly sourceFile: SourceFile; readonly node: Node | NodeArray<TypeParameterDeclaration>; }[] = [];

public static fromContext(context: TextChangesContext): ChangeTracker {

return new ChangeTracker(getNewLineOrDefaultFromHost(context.host, context.formatContext.options), context.formatContext);

}

public static with(context: TextChangesContext, cb: (tracker: ChangeTracker) => void): FileTextChanges[] {

const tracker = ChangeTracker.fromContext(context);

cb(tracker);

return tracker.getChanges();

}

/** Public for tests only. Other callers should use `ChangeTracker.with`. */

constructor(private readonly newLineCharacter: string, private readonly formatContext: formatting.FormatContext) {}

public pushRaw(sourceFile: SourceFile, change: FileTextChanges) {

Debug.assertEqual(sourceFile.fileName, change.fileName);

for (const c of change.textChanges) {

this.changes.push({

kind: ChangeKind.Text,

sourceFile,

text: c.newText,

range: createTextRangeFromSpan(c.span),

});

}

}

public deleteRange(sourceFile: SourceFile, range: TextRange): void {

this.changes.push({ kind: ChangeKind.Remove, sourceFile, range });

}

delete(sourceFile: SourceFile, node: Node | NodeArray<TypeParameterDeclaration>): void {

this.deletedNodes.push({ sourceFile, node });

}

/** Stop! Consider using `delete` instead, which has logic for deleting nodes from delimited lists. */

public deleteNode(sourceFile: SourceFile, node: Node, options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }): void {

this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options));

}

public deleteNodes(sourceFile: SourceFile, nodes: readonly Node[], options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }, hasTrailingComment: boolean): void {

// When deleting multiple nodes we need to track if the end position is including multiline trailing comments.

for (const node of nodes) {

const pos = getAdjustedStartPosition(sourceFile, node, options, hasTrailingComment);

const end = getAdjustedEndPosition(sourceFile, node, options);

this.deleteRange(sourceFile, { pos, end });

hasTrailingComment = !!getEndPositionOfMultilineTrailingComment(sourceFile, node, options);

}

}

public deleteModifier(sourceFile: SourceFile, modifier: Modifier): void {

this.deleteRange(sourceFile, { pos: modifier.getStart(sourceFile), end: skipTrivia(sourceFile.text, modifier.end, /*stopAfterLineBreak*/ true) });

}

public deleteNodeRange(sourceFile: SourceFile, startNode: Node, endNode: Node, options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }): void {

const startPosition = getAdjustedStartPosition(sourceFile, startNode, options);

const endPosition = getAdjustedEndPosition(sourceFile, endNode, options);

this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });

}

public deleteNodeRangeExcludingEnd(sourceFile: SourceFile, startNode: Node, afterEndNode: Node | undefined, options: ConfigurableStartEnd = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }): void {

const startPosition = getAdjustedStartPosition(sourceFile, startNode, options);

const endPosition = afterEndNode === undefined ? sourceFile.text.length : getAdjustedStartPosition(sourceFile, afterEndNode, options);

this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });

}

public replaceRange(sourceFile: SourceFile, range: TextRange, newNode: Node, options: InsertNodeOptions = {}): void {

this.changes.push({ kind: ChangeKind.ReplaceWithSingleNode, sourceFile, range, options, node: newNode });

}

public replaceNode(sourceFile: SourceFile, oldNode: Node, newNode: Node, options: ChangeNodeOptions = useNonAdjustedPositions): void {

this.replaceRange(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNode, options);

}

public replaceNodeRange(sourceFile: SourceFile, startNode: Node, endNode: Node, newNode: Node, options: ChangeNodeOptions = useNonAdjustedPositions): void {

this.replaceRange(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNode, options);

}

private replaceRangeWithNodes(sourceFile: SourceFile, range: TextRange, newNodes: readonly Node[], options: ReplaceWithMultipleNodesOptions & ConfigurableStartEnd = {}): void {

this.changes.push({ kind: ChangeKind.ReplaceWithMultipleNodes, sourceFile, range, options, nodes: newNodes });

}

public replaceNodeWithNodes(sourceFile: SourceFile, oldNode: Node, newNodes: readonly Node[], options: ChangeNodeOptions = useNonAdjustedPositions): void {

this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNodes, options);

}

public replaceNodeWithText(sourceFile: SourceFile, oldNode: Node, text: string): void {

this.replaceRangeWithText(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, useNonAdjustedPositions), text);

}

public replaceNodeRangeWithNodes(sourceFile: SourceFile, startNode: Node, endNode: Node, newNodes: readonly Node[], options: ReplaceWithMultipleNodesOptions & ConfigurableStartEnd = useNonAdjustedPositions): void {

this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNodes, options);

}

public nodeHasTrailingComment(sourceFile: SourceFile, oldNode: Node, configurableEnd: ConfigurableEnd = useNonAdjustedPositions): boolean {

return !!getEndPositionOfMultilineTrailingComment(sourceFile, oldNode, configurableEnd);

}

private nextCommaToken(sourceFile: SourceFile, node: Node): Node | undefined {

const next = findNextToken(node, node.parent, sourceFile);

return next && next.kind === SyntaxKind.CommaToken ? next : undefined;

}

public replacePropertyAssignment(sourceFile: SourceFile, oldNode: PropertyAssignment, newNode: PropertyAssignment): void {

const suffix = this.nextCommaToken(sourceFile, oldNode) ? "" : ("," + this.newLineCharacter);

this.replaceNode(sourceFile, oldNode, newNode, { suffix });

}

public insertNodeAt(sourceFile: SourceFile, pos: number, newNode: Node, options: InsertNodeOptions = {}): void {

this.replaceRange(sourceFile, createRange(pos), newNode, options);

}

private insertNodesAt(sourceFile: SourceFile, pos: number, newNodes: readonly Node[], options: ReplaceWithMultipleNodesOptions = {}): void {

this.replaceRangeWithNodes(sourceFile, createRange(pos), newNodes, options);

}

public insertNodeAtTopOfFile(sourceFile: SourceFile, newNode: Statement, blankLineBetween: boolean): void {

this.insertAtTopOfFile(sourceFile, newNode, blankLineBetween);

}

public insertNodesAtTopOfFile(sourceFile: SourceFile, newNodes: readonly Statement[], blankLineBetween: boolean): void {

this.insertAtTopOfFile(sourceFile, newNodes, blankLineBetween);

}

private insertAtTopOfFile(sourceFile: SourceFile, insert: Statement | readonly Statement[], blankLineBetween: boolean): void {

const pos = getInsertionPositionAtSourceFileTop(sourceFile);

const options = {

prefix: pos === 0 ? undefined : this.newLineCharacter,

suffix: (isLineBreak(sourceFile.text.charCodeAt(pos)) ? "" : this.newLineCharacter) + (blankLineBetween ? this.newLineCharacter : ""),

};

if (isArray(insert)) {

this.insertNodesAt(sourceFile, pos, insert, options);

}

else {

this.insertNodeAt(sourceFile, pos, insert, options);

}

}

public insertNodesAtEndOfFile(

sourceFile: SourceFile,

newNodes: readonly Statement[],

blankLineBetween: boolean,

): void {

this.insertAtEndOfFile(sourceFile, newNodes, blankLineBetween);

}

private insertAtEndOfFile(

sourceFile: SourceFile,

insert: readonly Statement[],

blankLineBetween: boolean,

): void {

const pos = sourceFile.end + 1;

const options = {

prefix: this.newLineCharacter,

suffix: this.newLineCharacter + (blankLineBetween ? this.newLineCharacter : ""),

};

this.insertNodesAt(sourceFile, pos, insert, options);

}

public insertStatementsInNewFile(fileName: string, statements: readonly (Statement | SyntaxKind.NewLineTrivia)[], oldFile?: SourceFile): void {

if (!this.newFileChanges) {

this.newFileChanges = createMultiMap<string, NewFileInsertion>();

}

this.newFileChanges.add(fileName, { oldFile, statements });

}

public insertFirstParameter(sourceFile: SourceFile, parameters: NodeArray<ParameterDeclaration>, newParam: ParameterDeclaration): void {

const p0 = firstOrUndefined(parameters);

if (p0) {

this.insertNodeBefore(sourceFile, p0, newParam);

}

else {

this.insertNodeAt(sourceFile, parameters.pos, newParam);

}

}

public insertNodeBefore(sourceFile: SourceFile, before: Node, newNode: Node, blankLineBetween = false, options: ConfigurableStartEnd = {}): void {

this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween));

}

public insertNodesBefore(sourceFile: SourceFile, before: Node, newNodes: readonly Node[], blankLineBetween = false, options: ConfigurableStartEnd = {}): void {

this.insertNodesAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNodes, this.getOptionsForInsertNodeBefore(before, first(newNodes), blankLineBetween));

}

public insertModifierAt(sourceFile: SourceFile, pos: number, modifier: SyntaxKind, options: InsertNodeOptions = {}): void {

this.insertNodeAt(sourceFile, pos, factory.createToken(modifier), options);

}

public insertModifierBefore(sourceFile: SourceFile, modifier: SyntaxKind, before: Node): void {

return this.insertModifierAt(sourceFile, before.getStart(sourceFile), modifier, { suffix: " " });

}

public insertCommentBeforeLine(sourceFile: SourceFile, lineNumber: number, position: number, commentText: string): void {

const lineStartPosition = getStartPositionOfLine(lineNumber, sourceFile);

const startPosition = getFirstNonSpaceCharacterPosition(sourceFile.text, lineStartPosition);

// First try to see if we can put the comment on the previous line.

// We need to make sure that we are not in the middle of a string literal or a comment.

// If so, we do not want to separate the node from its comment if we can.

// Otherwise, add an extra new line immediately before the error span.

const insertAtLineStart = isValidLocationToAddComment(sourceFile, startPosition);

const token = getTouchingToken(sourceFile, insertAtLineStart ? startPosition : position);

const indent = sourceFile.text.slice(lineStartPosition, startPosition);

const text = `${insertAtLineStart ? "" : this.newLineCharacter}//${commentText}${this.newLineCharacter}${indent}`;

this.insertText(sourceFile, token.getStart(sourceFile), text);

}

public insertJsdocCommentBefore(sourceFile: SourceFile, node: HasJSDoc, tag: JSDoc): void {

const fnStart = node.getStart(sourceFile);

if (node.jsDoc) {

for (const jsdoc of node.jsDoc) {

this.deleteRange(sourceFile, {

pos: getLineStartPositionForPosition(jsdoc.getStart(sourceFile), sourceFile),

end: getAdjustedEndPosition(sourceFile, jsdoc, /*options*/ {}),

});

}

}

const startPosition = getPrecedingNonSpaceCharacterPosition(sourceFile.text, fnStart - 1);

const indent = sourceFile.text.slice(startPosition, fnStart);

this.insertNodeAt(sourceFile, fnStart, tag, { suffix: this.newLineCharacter + indent });

}

private createJSDocText(sourceFile: SourceFile, node: HasJSDoc) {

const comments = flatMap(node.jsDoc, jsDoc => isString(jsDoc.comment) ? factory.createJSDocText(jsDoc.comment) : jsDoc.comment) as JSDocComment[];

const jsDoc = singleOrUndefined(node.jsDoc);

return jsDoc && positionsAreOnSameLine(jsDoc.pos, jsDoc.end, sourceFile) && length(comments) === 0 ? undefined :

factory.createNodeArray(intersperse(comments, factory.createJSDocText("\n")));

}

public replaceJSDocComment(sourceFile: SourceFile, node: HasJSDoc, tags: readonly JSDocTag[]) {

this.insertJsdocCommentBefore(sourceFile, updateJSDocHost(node), factory.createJSDocComment(this.createJSDocText(sourceFile, node), factory.createNodeArray(tags)));

}

public addJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, newTags: readonly JSDocTag[]): void {

const oldTags = flatMapToMutable(parent.jsDoc, j => j.tags);

const unmergedNewTags = newTags.filter(newTag =>

!oldTags.some((tag, i) => {

const merged = tryMergeJsdocTags(tag, newTag);

if (merged) oldTags[i] = merged;

return !!merged;

})

);

this.replaceJSDocComment(sourceFile, parent, [...oldTags, ...unmergedNewTags]);

}

public filterJSDocTags(sourceFile: SourceFile, parent: HasJSDoc, predicate: (tag: JSDocTag) => boolean): void {

this.replaceJSDocComment(sourceFile, parent, filter(flatMapToMutable(parent.jsDoc, j => j.tags), predicate));

}

public replaceRangeWithText(sourceFile: SourceFile, range: TextRange, text: string): void {

this.changes.push({ kind: ChangeKind.Text, sourceFile, range, text });

}

public insertText(sourceFile: SourceFile, pos: number, text: string): void {

this.replaceRangeWithText(sourceFile, createRange(pos), text);

}

/** Prefer this over replacing a node with another that has a type annotation, as it avoids reformatting the other parts of the node. */

public tryInsertTypeAnnotation(sourceFile: SourceFile, node: TypeAnnotatable, type: TypeNode): boolean {

let endNode: Node | undefined;

if (isFunctionLike(node)) {

endNode = findChildOfKind(node, SyntaxKind.CloseParenToken, sourceFile);

if (!endNode) {

if (!isArrowFunction(node)) return false; // Function missing parentheses, give up

// If no `)`, is an arrow function `x => x`, so use the end of the first parameter

endNode = first(node.parameters);

}

}

else {

endNode = (node.kind === SyntaxKind.VariableDeclaration ? node.exclamationToken : node.questionToken) ?? node.name;

}

this.insertNodeAt(sourceFile, endNode.end, type, { prefix: ": " });

return true;

}

public tryInsertThisTypeAnnotation(sourceFile: SourceFile, node: ThisTypeAnnotatable, type: TypeNode): void {

const start = findChildOfKind(node, SyntaxKind.OpenParenToken, sourceFile)!.getStart(sourceFile) + 1;

const suffix = node.parameters.length ? ", " : "";

this.insertNodeAt(sourceFile, start, type, { prefix: "this: ", suffix });

}

public insertTypeParameters(sourceFile: SourceFile, node: SignatureDeclaration, typeParameters: readonly TypeParameterDeclaration[]): void {

// If no `(`, is an arrow function `x => x`, so use the pos of the first parameter

const start = (findChildOfKind(node, SyntaxKind.OpenParenToken, sourceFile) || first(node.parameters)).getStart(sourceFile);

this.insertNodesAt(sourceFile, start, typeParameters, { prefix: "<", suffix: ">", joiner: ", " });

}

private getOptionsForInsertNodeBefore(before: Node, inserted: Node, blankLineBetween: boolean): InsertNodeOptions {

if (isStatement(before) || isClassElement(before)) {

return { suffix: blankLineBetween ? this.newLineCharacter + this.newLineCharacter : this.newLineCharacter };

}

else if (isVariableDeclaration(before)) { // insert `x = 1, ` into `const x = 1, y = 2;

return { suffix: ", " };

}

else if (isParameter(before)) {

return isParameter(inserted) ? { suffix: ", " } : {};

}

else if (isStringLiteral(before) && isImportDeclaration(before.parent) || isNamedImports(before)) {

return { suffix: ", " };

}

else if (isImportSpecifier(before)) {

return { suffix: "," + (blankLineBetween ? this.newLineCharacter : " ") };

}

return Debug.failBadSyntaxKind(before); // We haven't handled this kind of node yet -- add it

}

public insertNodeAtConstructorStart(sourceFile: SourceFile, ctr: ConstructorDeclaration, newStatement: Statement): void {

const firstStatement = firstOrUndefined(ctr.body!.statements);

if (!firstStatement || !ctr.body!.multiLine) {

this.replaceConstructorBody(sourceFile, ctr, [newStatement, ...ctr.body!.statements]);

}

else {

this.insertNodeBefore(sourceFile, firstStatement, newStatement);

}

}

public insertNodeAtConstructorStartAfterSuperCall(sourceFile: SourceFile, ctr: ConstructorDeclaration, newStatement: Statement): void {

const superCallStatement = find(ctr.body!.statements, stmt => isExpressionStatement(stmt) && isSuperCall(stmt.expression));

if (!superCallStatement || !ctr.body!.multiLine) {

this.replaceConstructorBody(sourceFile, ctr, [...ctr.body!.statements, newStatement]);

}

else {

this.insertNodeAfter(sourceFile, superCallStatement, newStatement);

}

}

public insertNodeAtConstructorEnd(sourceFile: SourceFile, ctr: ConstructorDeclaration, newStatement: Statement): void {

const lastStatement = lastOrUndefined(ctr.body!.statements);

if (!lastStatement || !ctr.body!.multiLine) {

this.replaceConstructorBody(sourceFile, ctr, [...ctr.body!.statements, newStatement]);

}

else {

this.insertNodeAfter(sourceFile, lastStatement, newStatement);

}

}

private replaceConstructorBody(sourceFile: SourceFile, ctr: ConstructorDeclaration, statements: readonly Statement[]): void {

this.replaceNode(sourceFile, ctr.body!, factory.createBlock(statements, /*multiLine*/ true));

}

public insertNodeAtEndOfScope(sourceFile: SourceFile, scope: Node, newNode: Node): void {

const pos = getAdjustedStartPosition(sourceFile, scope.getLastToken()!, {});

this.insertNodeAt(sourceFile, pos, newNode, {

prefix: isLineBreak(sourceFile.text.charCodeAt(scope.getLastToken()!.pos)) ? this.newLineCharacter : this.newLineCharacter + this.newLineCharacter,

suffix: this.newLineCharacter,

});

}

public insertMemberAtStart(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | TypeLiteralNode | EnumDeclaration, newElement: ClassElement | PropertySignature | MethodSignature | EnumMember): void {

this.insertNodeAtStartWorker(sourceFile, node, newElement);

}

public insertNodeAtObjectStart(sourceFile: SourceFile, obj: ObjectLiteralExpression, newElement: ObjectLiteralElementLike): void {

this.insertNodeAtStartWorker(sourceFile, obj, newElement);

}

private insertNodeAtStartWorker(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode | EnumDeclaration, newElement: ClassElement | ObjectLiteralElementLike | PropertySignature | MethodSignature | EnumMember): void {

const indentation = this.guessIndentationFromExistingMembers(sourceFile, node) ?? this.computeIndentationForNewMember(sourceFile, node);

this.insertNodeAt(sourceFile, getMembersOrProperties(node).pos, newElement, this.getInsertNodeAtStartInsertOptions(sourceFile, node, indentation));

}

/**

* Tries to guess the indentation from the existing members of a class/interface/object. All members must be on

* new lines and must share the same indentation.

*/

private guessIndentationFromExistingMembers(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode | EnumDeclaration) {

let indentation: number | undefined;

let lastRange: TextRange = node;

for (const member of getMembersOrProperties(node)) {

if (rangeStartPositionsAreOnSameLine(lastRange, member, sourceFile)) {

// each indented member must be on a new line

return undefined;

}

const memberStart = member.getStart(sourceFile);

const memberIndentation = formatting.SmartIndenter.findFirstNonWhitespaceColumn(getLineStartPositionForPosition(memberStart, sourceFile), memberStart, sourceFile, this.formatContext.options);

if (indentation === undefined) {

indentation = memberIndentation;

}

else if (memberIndentation !== indentation) {

// indentation of multiple members is not consistent

return undefined;

}

lastRange = member;

}

return indentation;

}

private computeIndentationForNewMember(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode | EnumDeclaration) {

const nodeStart = node.getStart(sourceFile);

return formatting.SmartIndenter.findFirstNonWhitespaceColumn(getLineStartPositionForPosition(nodeStart, sourceFile), nodeStart, sourceFile, this.formatContext.options)

+ (this.formatContext.options.indentSize ?? 4);

}

private getInsertNodeAtStartInsertOptions(sourceFile: SourceFile, node: ClassLikeDeclaration | InterfaceDeclaration | ObjectLiteralExpression | TypeLiteralNode | EnumDeclaration, indentation: number): InsertNodeOptions {

// Rules:

// - Always insert leading newline.

// - For object literals:

// - Add a trailing comma if there are existing members in the node, or the source file is not a JSON file

// (because trailing commas are generally illegal in a JSON file).

// - Add a leading comma if the source file is not a JSON file, there are existing insertions,

// and the node is empty (because we didn't add a trailing comma per the previous rule).

// - Only insert a trailing newline if body is single-line and there are no other insertions for the node.

// NOTE: This is handled in `finishClassesWithNodesInsertedAtStart`.

const members = getMembersOrProperties(node);

const isEmpty = members.length === 0;

const isFirstInsertion = addToSeen(this.classesWithNodesInsertedAtStart, getNodeId(node), { node, sourceFile });

const insertTrailingComma = isObjectLiteralExpression(node) && (!isJsonSourceFile(sourceFile) || !isEmpty);

const insertLeadingComma = isObjectLiteralExpression(node) && isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion;

return {

indentation,

prefix: (insertLeadingComma ? "," : "") + this.newLineCharacter,

suffix: insertTrailingComma ? "," : isInterfaceDeclaration(node) && isEmpty ? ";" : "",

};

}

public insertNodeAfterComma(sourceFile: SourceFile, after: Node, newNode: Node): void {

const endPosition = this.insertNodeAfterWorker(sourceFile, this.nextCommaToken(sourceFile, after) || after, newNode);

this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after));

}

public insertNodeAfter(sourceFile: SourceFile, after: Node, newNode: Node): void {

const endPosition = this.insertNodeAfterWorker(sourceFile, after, newNode);

this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after));

}

public insertNodeAtEndOfList(sourceFile: SourceFile, list: NodeArray<Node>, newNode: Node): void {

this.insertNodeAt(sourceFile, list.end, newNode, { prefix: ", " });

}

public insertNodesAfter(sourceFile: SourceFile, after: Node, newNodes: readonly Node[]): void {

const endPosition = this.insertNodeAfterWorker(sourceFile, after, first(newNodes));

this.insertNodesAt(sourceFile, endPosition, newNodes, this.getInsertNodeAfterOptions(sourceFile, after));

}

private insertNodeAfterWorker(sourceFile: SourceFile, after: Node, newNode: Node): number {

if (needSemicolonBetween(after, newNode)) {

// check if previous statement ends with semicolon

// if not - insert semicolon to preserve the code from changing the meaning due to ASI

if (sourceFile.text.charCodeAt(after.end - 1) !== CharacterCodes.semicolon) {

this.replaceRange(sourceFile, createRange(after.end), factory.createToken(SyntaxKind.SemicolonToken));

}

}

const endPosition = getAdjustedEndPosition(sourceFile, after, {});

return endPosition;

}

private getInsertNodeAfterOptions(sourceFile: SourceFile, after: Node): InsertNodeOptions {

const options = this.getInsertNodeAfterOptionsWorker(after);

return {

...options,

prefix: after.end === sourceFile.end && isStatement(after) ? (options.prefix ? `\n${options.prefix}` : "\n") : options.prefix,

};

}

private getInsertNodeAfterOptionsWorker(node: Node): InsertNodeOptions {

switch (node.kind) {

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ModuleDeclaration:

return { prefix: this.newLineCharacter, suffix: this.newLineCharacter };

case SyntaxKind.VariableDeclaration:

case SyntaxKind.StringLiteral:

case SyntaxKind.Identifier:

return { prefix: ", " };

case SyntaxKind.PropertyAssignment:

return { suffix: "," + this.newLineCharacter };

case SyntaxKind.ExportKeyword:

return { prefix: " " };

case SyntaxKind.Parameter:

return {};

default:

Debug.assert(isStatement(node) || isClassOrTypeElement(node)); // Else we haven't handled this kind of node yet -- add it

return { suffix: this.newLineCharacter };

}

}

public insertName(sourceFile: SourceFile, node: FunctionExpression | ClassExpression | ArrowFunction, name: string): void {

Debug.assert(!node.name);

if (node.kind === SyntaxKind.ArrowFunction) {

const arrow = findChildOfKind(node, SyntaxKind.EqualsGreaterThanToken, sourceFile)!;

const lparen = findChildOfKind(node, SyntaxKind.OpenParenToken, sourceFile);

if (lparen) {

// `() => {}` --> `function f() {}`

this.insertNodesAt(sourceFile, lparen.getStart(sourceFile), [factory.createToken(SyntaxKind.FunctionKeyword), factory.createIdentifier(name)], { joiner: " " });

deleteNode(this, sourceFile, arrow);

}

else {

// `x => {}` -> `function f(x) {}`

this.insertText(sourceFile, first(node.parameters).getStart(sourceFile), `function ${name}(`);

// Replacing full range of arrow to get rid of the leading space -- replace ` =>` with `)`

this.replaceRange(sourceFile, arrow, factory.createToken(SyntaxKind.CloseParenToken));

}

if (node.body.kind !== SyntaxKind.Block) {

// `() => 0` => `function f() { return 0; }`

this.insertNodesAt(sourceFile, node.body.getStart(sourceFile), [factory.createToken(SyntaxKind.OpenBraceToken), factory.createToken(SyntaxKind.ReturnKeyword)], { joiner: " ", suffix: " " });