leadingTrivia: TextRangeWithKind[];

token: TextRangeWithKind;

trailingTrivia: TextRangeWithKind[];

getIndentationForToken(tokenLine: number, tokenKind: SyntaxKind, container: Node): number;

getIndentationForComment(owningToken: SyntaxKind, tokenIndentation: number, container: Node): number;

/**

getIndentation(): number;

/**

getDelta(child: TextRangeWithKind): number;

/**

recomputeIndentation(lineAddedByFormatting: boolean): void;

const line = sourceFile.getLineAndCharacterOfPosition(position).line;

if (line === 0) {

return [];

}

// After the enter key, the cursor is now at a new line. The new line may or may not contain non-whitespace characters.

// If the new line has only whitespaces, we won't want to format this line, because that would remove the indentation as

// trailing whitespaces. So the end of the formatting span should be the later one between:

// 1. the end of the previous line

// 2. the last non-whitespace character in the current line

let endOfFormatSpan = getEndLinePosition(line, sourceFile);

while (isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(endOfFormatSpan))) {

endOfFormatSpan--;

}

// if the character at the end of the span is a line break, we shouldn't include it, because it indicates we don't want to

// touch the current line at all. Also, on some OSes the line break consists of two characters (\r\n), we should test if the

// previous character before the end of format span is line break character as well.

if (isLineBreak(sourceFile.text.charCodeAt(endOfFormatSpan))) {

endOfFormatSpan--;

}

const span = {

// get start position for the previous line

pos: getStartPositionOfLine(line - 1, sourceFile),

// end value is exclusive so add 1 to the result

end: endOfFormatSpan + 1

};

return formatSpan(span, sourceFile, options, rulesProvider, FormattingRequestKind.FormatOnEnter);

const openingCurly = findImmediatelyPrecedingTokenOfKind(position, SyntaxKind.OpenBraceToken, sourceFile);

if (!openingCurly) {

return [];

}

const curlyBraceRange = openingCurly.parent;

const outermostNode = findOutermostNodeWithinListLevel(curlyBraceRange);

/**

const textRange: TextRange = {

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

end: position

};

return formatSpan(textRange, sourceFile, options, rulesProvider, FormattingRequestKind.FormatOnOpeningCurlyBrace);

const span = {

pos: 0,

end: sourceFile.text.length

};

return formatSpan(span, sourceFile, options, rulesProvider, FormattingRequestKind.FormatDocument);

// format from the beginning of the line

const span = {

pos: getLineStartPositionForPosition(start, sourceFile),

end,

};

return formatSpan(span, sourceFile, options, rulesProvider, FormattingRequestKind.FormatSelection);

const precedingToken = findPrecedingToken(end, sourceFile);

return precedingToken && precedingToken.kind === expectedTokenKind && end === precedingToken.getEnd() ?

precedingToken :

undefined;

let current = node;

while (current &&

current.parent &&

current.parent.end === node.end &&

!isListElement(current.parent, current)) {

current = current.parent;

}

return current;

switch (parent.kind) {

case SyntaxKind.ClassDeclaration:

case SyntaxKind.InterfaceDeclaration:

return rangeContainsRange((<InterfaceDeclaration>parent).members, node);

case SyntaxKind.ModuleDeclaration:

const body = (<ModuleDeclaration>parent).body;

return body && body.kind === SyntaxKind.ModuleBlock && rangeContainsRange((<ModuleBlock>body).statements, node);

case SyntaxKind.SourceFile:

case SyntaxKind.Block:

case SyntaxKind.ModuleBlock:

return rangeContainsRange((<Block>parent).statements, node);

case SyntaxKind.CatchClause:

return rangeContainsRange((<CatchClause>parent).block.statements, node);

}

return false;

return find(sourceFile);

function find(n: Node): Node {

const candidate = forEachChild(n, c => startEndContainsRange(c.getStart(sourceFile), c.end, range) && c);

if (candidate) {

const result = find(candidate);

if (result) {

return result;

}

}

return n;

}

if (!errors.length) {

return rangeHasNoErrors;

}

// pick only errors that fall in range

const sorted = errors

.filter(d => rangeOverlapsWithStartEnd(originalRange, d.start, d.start + d.length))

.sort((e1, e2) => e1.start - e2.start);

if (!sorted.length) {

return rangeHasNoErrors;

}

let index = 0;

return r => {

// in current implementation sequence of arguments [r1, r2...] is monotonically increasing.

// 'index' tracks the index of the most recent error that was checked.

while (true) {

if (index >= sorted.length) {

// all errors in the range were already checked -> no error in specified range

return false;

}

const error = sorted[index];

if (r.end <= error.start) {

// specified range ends before the error refered by 'index' - no error in range

return false;

}

if (startEndOverlapsWithStartEnd(r.pos, r.end, error.start, error.start + error.length)) {

// specified range overlaps with error range

return true;

}

index++;

}

};

function rangeHasNoErrors(): boolean {

return false;

}

const start = enclosingNode.getStart(sourceFile);

if (start === originalRange.pos && enclosingNode.end === originalRange.end) {

return start;

}

const precedingToken = findPrecedingToken(originalRange.pos, sourceFile);

if (!precedingToken) {

// no preceding token found - start from the beginning of enclosing node

return enclosingNode.pos;

}

// preceding token ends after the start of original range (i.e when originalRange.pos falls in the middle of literal)

// start from the beginning of enclosingNode to handle the entire 'originalRange'

if (precedingToken.end >= originalRange.pos) {

return enclosingNode.pos;

}

return precedingToken.end;

let previousLine = Constants.Unknown;

let child: Node;

while (n) {

const line = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)).line;

if (previousLine !== Constants.Unknown && line !== previousLine) {

break;

}

if (SmartIndenter.shouldIndentChildNode(n, child)) {

return options.indentSize;

}

previousLine = line;

child = n;

n = n.parent;

}

return 0;

const range = { pos: 0, end: sourceFileLike.text.length };

return getFormattingScanner(sourceFileLike.text, languageVariant, range.pos, range.end, scanner => formatSpanWorker(

range,

node,

initialIndentation,

delta,

scanner,

rulesProvider.getFormatOptions(),

rulesProvider,

FormattingRequestKind.FormatSelection,

_ => false, // assume that node does not have any errors

sourceFileLike));

if (!node) {

return [];

}

const span = {

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

end: node.end

};

return formatSpan(span, sourceFile, options, rulesProvider, requestKind);

sourceFile: SourceFile,

options: FormatCodeSettings,

rulesProvider: RulesProvider,

requestKind: FormattingRequestKind): TextChange[] {

// find the smallest node that fully wraps the range and compute the initial indentation for the node

const enclosingNode = findEnclosingNode(originalRange, sourceFile);

return getFormattingScanner(sourceFile.text, sourceFile.languageVariant, getScanStartPosition(enclosingNode, originalRange, sourceFile), originalRange.end, scanner => formatSpanWorker(

originalRange,

enclosingNode,

SmartIndenter.getIndentationForNode(enclosingNode, originalRange, sourceFile, options),

getOwnOrInheritedDelta(enclosingNode, options, sourceFile),

scanner,

options,

rulesProvider,

requestKind,

prepareRangeContainsErrorFunction(sourceFile.parseDiagnostics, originalRange),

sourceFile));

enclosingNode: Node,

initialIndentation: number,

delta: number,

formattingScanner: FormattingScanner,

options: FormatCodeSettings,

rulesProvider: RulesProvider,

requestKind: FormattingRequestKind,

rangeContainsError: (r: TextRange) => boolean,

sourceFile: SourceFileLike): TextChange[] {

// formatting context is used by rules provider

const formattingContext = new FormattingContext(sourceFile, requestKind, options);

let previousRange: TextRangeWithKind;

let previousParent: Node;

let previousRangeStartLine: number;

let lastIndentedLine: number;

let indentationOnLastIndentedLine: number;

const edits: TextChange[] = [];

formattingScanner.advance();

if (formattingScanner.isOnToken()) {

const startLine = sourceFile.getLineAndCharacterOfPosition(enclosingNode.getStart(sourceFile)).line;

let undecoratedStartLine = startLine;

if (enclosingNode.decorators) {

undecoratedStartLine = sourceFile.getLineAndCharacterOfPosition(getNonDecoratorTokenPosOfNode(enclosingNode, sourceFile)).line;

}

processNode(enclosingNode, enclosingNode, startLine, undecoratedStartLine, initialIndentation, delta);

}

if (!formattingScanner.isOnToken()) {

const leadingTrivia = formattingScanner.getCurrentLeadingTrivia();

if (leadingTrivia) {

processTrivia(leadingTrivia, enclosingNode, enclosingNode, /*dynamicIndentation*/ undefined);

trimTrailingWhitespacesForRemainingRange();

}

}

return edits;

// local functions

/** Tries to compute the indentation for a list element.

function tryComputeIndentationForListItem(startPos: number,

endPos: number,

parentStartLine: number,

range: TextRange,

inheritedIndentation: number): number {

if (rangeOverlapsWithStartEnd(range, startPos, endPos) ||

rangeContainsStartEnd(range, startPos, endPos) /* Not to miss zero-range nodes e.g. JsxText */) {

if (inheritedIndentation !== Constants.Unknown) {

return inheritedIndentation;

}

}

else {

const startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line;

const startLinePosition = getLineStartPositionForPosition(startPos, sourceFile);

const column = SmartIndenter.findFirstNonWhitespaceColumn(startLinePosition, startPos, sourceFile, options);

if (startLine !== parentStartLine || startPos === column) {

// Use the base indent size if it is greater than

// the indentation of the inherited predecessor.

const baseIndentSize = SmartIndenter.getBaseIndentation(options);

return baseIndentSize > column ? baseIndentSize : column;

}

}

return Constants.Unknown;

}

function computeIndentation(

node: TextRangeWithKind,

startLine: number,

inheritedIndentation: number,

parent: Node,

parentDynamicIndentation: DynamicIndentation,

effectiveParentStartLine: number): Indentation {

let indentation = inheritedIndentation;

let delta = SmartIndenter.shouldIndentChildNode(node) ? options.indentSize : 0;

if (effectiveParentStartLine === startLine) {

// if node is located on the same line with the parent

// - inherit indentation from the parent

// - push children if either parent of node itself has non-zero delta

indentation = startLine === lastIndentedLine

? indentationOnLastIndentedLine

: parentDynamicIndentation.getIndentation();

delta = Math.min(options.indentSize, parentDynamicIndentation.getDelta(node) + delta);

}

else if (indentation === Constants.Unknown) {

if (SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement(parent, node, startLine, sourceFile)) {

indentation = parentDynamicIndentation.getIndentation();

}

else {

indentation = parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(node);

}

}

return {

indentation,

delta

};

}

function getFirstNonDecoratorTokenOfNode(node: Node) {

if (node.modifiers && node.modifiers.length) {

return node.modifiers[0].kind;

}

switch (node.kind) {

case SyntaxKind.ClassDeclaration: return SyntaxKind.ClassKeyword;

case SyntaxKind.InterfaceDeclaration: return SyntaxKind.InterfaceKeyword;

case SyntaxKind.FunctionDeclaration: return SyntaxKind.FunctionKeyword;

case SyntaxKind.EnumDeclaration: return SyntaxKind.EnumDeclaration;

case SyntaxKind.GetAccessor: return SyntaxKind.GetKeyword;

case SyntaxKind.SetAccessor: return SyntaxKind.SetKeyword;

case SyntaxKind.MethodDeclaration:

if ((<MethodDeclaration>node).asteriskToken) {

return SyntaxKind.AsteriskToken;

}

// falls through

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.Parameter:

return getNameOfDeclaration(<Declaration>node).kind;

}

}

function getDynamicIndentation(node: Node, nodeStartLine: number, indentation: number, delta: number): DynamicIndentation {

return {

getIndentationForComment: (kind, tokenIndentation, container) => {

switch (kind) {

// preceding comment to the token that closes the indentation scope inherits the indentation from the scope

// .. {

// // comment

// }

case SyntaxKind.CloseBraceToken:

case SyntaxKind.CloseBracketToken:

case SyntaxKind.CloseParenToken:

return indentation + getEffectiveDelta(delta, container);

}

return tokenIndentation !== Constants.Unknown ? tokenIndentation : indentation;

},

getIndentationForToken: (line, kind, container) => {

if (nodeStartLine !== line && node.decorators) {

if (kind === getFirstNonDecoratorTokenOfNode(node)) {

// if this token is the first token following the list of decorators, we do not need to indent

return indentation;

}

}

switch (kind) {

// open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent

case SyntaxKind.OpenBraceToken:

case SyntaxKind.CloseBraceToken:

case SyntaxKind.OpenParenToken:

case SyntaxKind.CloseParenToken:

case SyntaxKind.ElseKeyword:

case SyntaxKind.WhileKeyword:

case SyntaxKind.AtToken:

return indentation;

case SyntaxKind.SlashToken:

case SyntaxKind.GreaterThanToken: {

if (container.kind === SyntaxKind.JsxOpeningElement ||

container.kind === SyntaxKind.JsxClosingElement ||

container.kind === SyntaxKind.JsxSelfClosingElement

) {

return indentation;

}

break;

}

case SyntaxKind.OpenBracketToken:

case SyntaxKind.CloseBracketToken: {

if (container.kind !== SyntaxKind.MappedType) {

return indentation;

}

break;

}

}

// if token line equals to the line of containing node (this is a first token in the node) - use node indentation

return nodeStartLine !== line ? indentation + getEffectiveDelta(delta, container) : indentation;

},

getIndentation: () => indentation,

getDelta: child => getEffectiveDelta(delta, child),

recomputeIndentation: lineAdded => {

if (node.parent && SmartIndenter.shouldIndentChildNode(node.parent, node)) {

if (lineAdded) {

indentation += options.indentSize;

}

else {

indentation -= options.indentSize;

}

if (SmartIndenter.shouldIndentChildNode(node)) {

delta = options.indentSize;

}

else {

delta = 0;

}

}

}

};

function getEffectiveDelta(delta: number, child: TextRangeWithKind) {

// Delta value should be zero when the node explicitly prevents indentation of the child node

return SmartIndenter.nodeWillIndentChild(node, child, /*indentByDefault*/ true) ? delta : 0;

}

}

function processNode(node: Node, contextNode: Node, nodeStartLine: number, undecoratedNodeStartLine: number, indentation: number, delta: number) {

if (!rangeOverlapsWithStartEnd(originalRange, node.getStart(sourceFile), node.getEnd())) {

return;

}

const nodeDynamicIndentation = getDynamicIndentation(node, nodeStartLine, indentation, delta);

// a useful observations when tracking context node

// /

// [a]

// / | \

// [b] [c] [d]

// node 'a' is a context node for nodes 'b', 'c', 'd'

// except for the leftmost leaf token in [b] - in this case context node ('e') is located somewhere above 'a'

// this rule can be applied recursively to child nodes of 'a'.

//

// context node is set to parent node value after processing every child node

// context node is set to parent of the token after processing every token

let childContextNode = contextNode;

// if there are any tokens that logically belong to node and interleave child nodes

// such tokens will be consumed in processChildNode for for the child that follows them

forEachChild(

node,

child => {

processChildNode(child, /*inheritedIndentation*/ Constants.Unknown, node, nodeDynamicIndentation, nodeStartLine, undecoratedNodeStartLine, /*isListItem*/ false);

},

nodes => {

processChildNodes(nodes, node, nodeStartLine, nodeDynamicIndentation);

});

// proceed any tokens in the node that are located after child nodes

while (formattingScanner.isOnToken()) {

const tokenInfo = formattingScanner.readTokenInfo(node);

if (tokenInfo.token.end > node.end) {

break;

}

consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node);

}

function processChildNode(

child: Node,

inheritedIndentation: number,

parent: Node,

parentDynamicIndentation: DynamicIndentation,

parentStartLine: number,

undecoratedParentStartLine: number,

isListItem: boolean,

isFirstListItem?: boolean): number {

const childStartPos = child.getStart(sourceFile);

const childStartLine = sourceFile.getLineAndCharacterOfPosition(childStartPos).line;

let undecoratedChildStartLine = childStartLine;

if (child.decorators) {

undecoratedChildStartLine = sourceFile.getLineAndCharacterOfPosition(getNonDecoratorTokenPosOfNode(child, sourceFile)).line;

}

// if child is a list item - try to get its indentation

let childIndentationAmount = Constants.Unknown;

if (isListItem) {

childIndentationAmount = tryComputeIndentationForListItem(childStartPos, child.end, parentStartLine, originalRange, inheritedIndentation);

if (childIndentationAmount !== Constants.Unknown) {

inheritedIndentation = childIndentationAmount;

}

}

// child node is outside the target range - do not dive inside

if (!rangeOverlapsWithStartEnd(originalRange, child.pos, child.end)) {

if (child.end < originalRange.pos) {

formattingScanner.skipToEndOf(child);

}

return inheritedIndentation;

}

if (child.getFullWidth() === 0) {

return inheritedIndentation;

}

while (formattingScanner.isOnToken()) {

// proceed any parent tokens that are located prior to child.getStart()

const tokenInfo = formattingScanner.readTokenInfo(node);

if (tokenInfo.token.end > childStartPos) {

// stop when formatting scanner advances past the beginning of the child

break;

}

consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, node);

}

if (!formattingScanner.isOnToken()) {

return inheritedIndentation;

}

// JSX text shouldn't affect indenting

if (isToken(child) && child.kind !== SyntaxKind.JsxText) {

// if child node is a token, it does not impact indentation, proceed it using parent indentation scope rules

const tokenInfo = formattingScanner.readTokenInfo(child);

Debug.assert(tokenInfo.token.end === child.end, "Token end is child end");

consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, child);

return inheritedIndentation;

}

const effectiveParentStartLine = child.kind === SyntaxKind.Decorator ? childStartLine : undecoratedParentStartLine;

const childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine);

processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta);

childContextNode = node;

if (isFirstListItem && parent.kind === SyntaxKind.ArrayLiteralExpression && inheritedIndentation === Constants.Unknown) {

inheritedIndentation = childIndentation.indentation;

}

return inheritedIndentation;

}

function processChildNodes(nodes: NodeArray<Node>,

parent: Node,

parentStartLine: number,

parentDynamicIndentation: DynamicIndentation): void {

Debug.assert(isNodeArray(nodes));

const listStartToken = getOpenTokenForList(parent, nodes);

const listEndToken = getCloseTokenForOpenToken(listStartToken);

let listDynamicIndentation = parentDynamicIndentation;

let startLine = parentStartLine;

if (listStartToken !== SyntaxKind.Unknown) {

// introduce a new indentation scope for lists (including list start and end tokens)

while (formattingScanner.isOnToken()) {

const tokenInfo = formattingScanner.readTokenInfo(parent);

if (tokenInfo.token.end > nodes.pos) {

// stop when formatting scanner moves past the beginning of node list

break;

}

else if (tokenInfo.token.kind === listStartToken) {

// consume list start token

startLine = sourceFile.getLineAndCharacterOfPosition(tokenInfo.token.pos).line;

const indentation =

computeIndentation(tokenInfo.token, startLine, Constants.Unknown, parent, parentDynamicIndentation, parentStartLine);

listDynamicIndentation = getDynamicIndentation(parent, parentStartLine, indentation.indentation, indentation.delta);

consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent);

}

else {

// consume any tokens that precede the list as child elements of 'node' using its indentation scope

consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation, parent);

}

}

}

let inheritedIndentation = Constants.Unknown;

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

const child = nodes[i];

inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, /*isListItem*/ true, /*isFirstListItem*/ i === 0);

}

if (listEndToken !== SyntaxKind.Unknown) {

if (formattingScanner.isOnToken()) {

const tokenInfo = formattingScanner.readTokenInfo(parent);

// consume the list end token only if it is still belong to the parent

// there might be the case when current token matches end token but does not considered as one

// function (x: function) <--

// without this check close paren will be interpreted as list end token for function expression which is wrong

if (tokenInfo.token.kind === listEndToken && rangeContainsRange(parent, tokenInfo.token)) {

// consume list end token

consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent);

}

}

}

}

function consumeTokenAndAdvanceScanner(currentTokenInfo: TokenInfo, parent: Node, dynamicIndentation: DynamicIndentation, container: Node): void {

Debug.assert(rangeContainsRange(parent, currentTokenInfo.token));

const lastTriviaWasNewLine = formattingScanner.lastTrailingTriviaWasNewLine();

let indentToken = false;

if (currentTokenInfo.leadingTrivia) {

processTrivia(currentTokenInfo.leadingTrivia, parent, childContextNode, dynamicIndentation);

}

let lineAdded: boolean;

const isTokenInRange = rangeContainsRange(originalRange, currentTokenInfo.token);

const tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos);

if (isTokenInRange) {

const rangeHasError = rangeContainsError(currentTokenInfo.token);

// save previousRange since processRange will overwrite this value with current one

const savePreviousRange = previousRange;

lineAdded = processRange(currentTokenInfo.token, tokenStart, parent, childContextNode, dynamicIndentation);

if (rangeHasError) {

// do not indent comments\token if token range overlaps with some error

indentToken = false;

}

else {

if (lineAdded !== undefined) {

indentToken = lineAdded;

}

else {

// indent token only if end line of previous range does not match start line of the token

const prevEndLine = savePreviousRange && sourceFile.getLineAndCharacterOfPosition(savePreviousRange.end).line;

indentToken = lastTriviaWasNewLine && tokenStart.line !== prevEndLine;

}

}

}

if (currentTokenInfo.trailingTrivia) {

processTrivia(currentTokenInfo.trailingTrivia, parent, childContextNode, dynamicIndentation);

}

if (indentToken) {

const tokenIndentation = (isTokenInRange && !rangeContainsError(currentTokenInfo.token)) ?

dynamicIndentation.getIndentationForToken(tokenStart.line, currentTokenInfo.token.kind, container) :

Constants.Unknown;

let indentNextTokenOrTrivia = true;

if (currentTokenInfo.leadingTrivia) {

const commentIndentation = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind, tokenIndentation, container);

for (const triviaItem of currentTokenInfo.leadingTrivia) {

const triviaInRange = rangeContainsRange(originalRange, triviaItem);

switch (triviaItem.kind) {

case SyntaxKind.MultiLineCommentTrivia:

if (triviaInRange) {

indentMultilineComment(triviaItem, commentIndentation, /*firstLineIsIndented*/ !indentNextTokenOrTrivia);

}

indentNextTokenOrTrivia = false;

break;

case SyntaxKind.SingleLineCommentTrivia:

if (indentNextTokenOrTrivia && triviaInRange) {

insertIndentation(triviaItem.pos, commentIndentation, /*lineAdded*/ false);

}

indentNextTokenOrTrivia = false;

break;

case SyntaxKind.NewLineTrivia:

indentNextTokenOrTrivia = true;

break;

}

}

}

// indent token only if is it is in target range and does not overlap with any error ranges

if (tokenIndentation !== Constants.Unknown && indentNextTokenOrTrivia) {

insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAdded);

lastIndentedLine = tokenStart.line;

indentationOnLastIndentedLine = tokenIndentation;

}

}

formattingScanner.advance();

childContextNode = parent;

}

}

function processTrivia(trivia: TextRangeWithKind[], parent: Node, contextNode: Node, dynamicIndentation: DynamicIndentation): void {

for (const triviaItem of trivia) {

if (isComment(triviaItem.kind) && rangeContainsRange(originalRange, triviaItem)) {

const triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos);

processRange(triviaItem, triviaItemStart, parent, contextNode, dynamicIndentation);