private static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxTree syntaxTree, SyntaxTriviaList leadingTrivia)
{
var triviaSpan = syntaxTree.GetLineSpan(leadingTrivia.FullSpan);
// There is no indentation when the leading trivia doesn't begin at the start of the line.
if ((triviaSpan.StartLinePosition == triviaSpan.EndLinePosition) && (triviaSpan.StartLinePosition.Character > 0))
{
return(0);
}
var builder = StringBuilderPool.Allocate();
foreach (SyntaxTrivia trivia in leadingTrivia.Reverse())
{
if (!trivia.IsKind(SyntaxKind.WhitespaceTrivia))
{
break;
}
builder.Insert(0, trivia.ToFullString());
}
var tabSize = indentationOptions.TabSize;
var indentationCount = 0;
for (var i = 0; i < builder.Length; i++)
{
indentationCount += builder[i] == '\t' ? tabSize - (indentationCount % tabSize) : 1;
}
StringBuilderPool.ReturnAndFree(builder);
return((indentationCount + (indentationOptions.IndentationSize / 2)) / indentationOptions.IndentationSize);
}
/// <summary>
/// Gets a whitespace trivia containing the proper amount of indentation for new lines in the query of which the given token is a part.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="token">A token within a query expression.</param>
/// <returns>A whitespace trivia containing the proper amount of indentation.</returns>
internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationOptions indentationOptions, SyntaxToken token)
{
var currentNode = token.Parent;
while (!currentNode.IsKind(SyntaxKind.QueryExpression))
{
currentNode = currentNode.Parent;
}
return GetQueryIndentationTrivia(indentationOptions, (QueryExpressionSyntax)currentNode);
}
/// <summary>
/// Gets a whitespace trivia containing the proper amount of indentation for new lines in the query of which the given token is a part.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="token">A token within a query expression.</param>
/// <returns>A whitespace trivia containing the proper amount of indentation.</returns>
internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationOptions indentationOptions, SyntaxToken token)
{
var currentNode = token.Parent;
while (!currentNode.IsKind(SyntaxKind.QueryExpression))
{
currentNode = currentNode.Parent;
}
return(GetQueryIndentationTrivia(indentationOptions, (QueryExpressionSyntax)currentNode));
}
/// <summary>
/// Gets a whitespace trivia containing the proper amount of indentation for new lines in the given query.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="queryExpression">The query expression to determine indentation from.</param>
/// <returns>A whitespace trivia containing the proper amount of indentation.</returns>
internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationOptions indentationOptions, QueryExpressionSyntax queryExpression)
{
var firstTokenOnTextLine = IndentationHelper.GetFirstTokenOnTextLine(queryExpression.FromClause.FromKeyword);
var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, firstTokenOnTextLine);
// add an extra indentation step when the first from clause is not properly indented yet
if (!firstTokenOnTextLine.IsKind(SyntaxKind.OpenParenToken) && (firstTokenOnTextLine != queryExpression.FromClause.FromKeyword))
{
indentationSteps++;
}
return IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps);
}
/// <summary>
/// Gets a whitespace trivia containing the proper amount of indentation for new lines in the given query.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="queryExpression">The query expression to determine indentation from.</param>
/// <returns>A whitespace trivia containing the proper amount of indentation.</returns>
internal static SyntaxTrivia GetQueryIndentationTrivia(IndentationOptions indentationOptions, QueryExpressionSyntax queryExpression)
{
var firstTokenOnTextLine = IndentationHelper.GetFirstTokenOnTextLine(queryExpression.FromClause.FromKeyword);
var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, firstTokenOnTextLine);
// add an extra indentation step when the first from clause is not properly indented yet
if (!firstTokenOnTextLine.IsKind(SyntaxKind.OpenParenToken) && (firstTokenOnTextLine != queryExpression.FromClause.FromKeyword))
{
indentationSteps++;
}
return(IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps));
}
private static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxTriviaList leadingTrivia)
{
var indentationString = string.Empty;
for (var i = leadingTrivia.Count - 1; (i >= 0) && leadingTrivia[i].IsKind(SyntaxKind.WhitespaceTrivia); i--)
{
indentationString = string.Concat(leadingTrivia[i].ToFullString(), indentationString);
}
var indentationCount = indentationString.ToCharArray().Sum(c => IndentationAmount(c, indentationOptions));
return(indentationCount / indentationOptions.IndentationSize);
}
/// <summary>
/// Generate a new indentation string.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="indentationSteps">The number of indentation steps.</param>
/// <returns>A string containing the amount of whitespace needed for the given indentation steps.</returns>
public static string GenerateIndentationString(IndentationOptions indentationOptions, int indentationSteps)
{
string result;
var indentationCount = indentationSteps * indentationOptions.IndentationSize;
if (indentationOptions.UseTabs)
{
var tabCount = indentationCount / indentationOptions.TabSize;
var spaceCount = indentationCount % indentationOptions.TabSize;
result = new string('\t', tabCount) + new string(' ', spaceCount);
}
else
{
result = new string(' ', indentationCount);
}
return result;
}
/// <summary>
/// Generate a new indentation string.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="indentationSteps">The number of indentation steps.</param>
/// <returns>A string containing the amount of whitespace needed for the given indentation steps.</returns>
public static string GenerateIndentationString(IndentationOptions indentationOptions, int indentationSteps)
{
string result;
var indentationCount = indentationSteps * indentationOptions.IndentationSize;
if (indentationOptions.UseTabs)
{
var tabCount = indentationCount / indentationOptions.TabSize;
var spaceCount = indentationCount % indentationOptions.TabSize;
result = new string('\t', tabCount) + new string(' ', spaceCount);
}
else
{
result = new string(' ', indentationCount);
}
return(result);
}
private static TextChange FixDiagnostic(IndentationOptions indentationOptions, SourceText sourceText, Diagnostic diagnostic)
{
TextSpan span = diagnostic.Location.SourceSpan;
TextLine startLine = sourceText.Lines.GetLineFromPosition(span.Start);
string text = sourceText.ToString(TextSpan.FromBounds(startLine.Start, span.End));
StringBuilder replacement = new StringBuilder(indentationOptions.TabSize * span.Length);
int column = 0;
for (int i = 0; i < text.Length; i++)
{
char c = text[i];
if (c == '\t')
{
var offsetWithinTabColumn = column % indentationOptions.TabSize;
var spaceCount = indentationOptions.TabSize - offsetWithinTabColumn;
if (i >= span.Start - startLine.Start)
{
replacement.Append(' ', spaceCount);
}
column += spaceCount;
}
else
{
if (i >= span.Start - startLine.Start)
{
replacement.Append(c);
}
if (c == '\n')
{
column = 0;
}
else
{
column++;
}
}
}
return new TextChange(span, replacement.ToString());
}
private static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxTriviaList leadingTrivia)
{
SyntaxTriviaList.Reversed reversed = leadingTrivia.Reverse();
int indentationCount = 0;
foreach (SyntaxTrivia trivia in reversed)
{
if (!trivia.IsKind(SyntaxKind.WhitespaceTrivia))
{
break;
}
foreach (char c in trivia.ToFullString())
{
indentationCount += c == '\t' ? indentationOptions.TabSize : 1;
}
}
return(indentationCount / indentationOptions.IndentationSize);
}
private static SyntaxNode UpdateSyntaxRoot(MemberDeclarationSyntax memberDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
var parentDeclaration = memberDeclaration.Parent;
var memberToMove = new MemberOrderHelper(memberDeclaration, checks);
if (parentDeclaration is TypeDeclarationSyntax)
{
return HandleTypeDeclaration(memberToMove, (TypeDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions);
}
if (parentDeclaration is NamespaceDeclarationSyntax)
{
return HandleNamespaceDeclaration(memberToMove, (NamespaceDeclarationSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions);
}
if (parentDeclaration is CompilationUnitSyntax)
{
return HandleCompilationUnitDeclaration(memberToMove, (CompilationUnitSyntax)parentDeclaration, checks, syntaxRoot, indentationOptions);
}
return syntaxRoot;
}
private static ConstructorDeclarationSyntax ReformatConstructorDeclaration(ConstructorDeclarationSyntax constructorDeclaration, IndentationOptions indentationOptions, SyntaxTrivia newLine)
{
var constructorInitializer = constructorDeclaration.Initializer;
var newParameterList = constructorDeclaration.ParameterList
.WithTrailingTrivia(constructorDeclaration.ParameterList.GetTrailingTrivia().WithoutTrailingWhitespace().Add(newLine));
var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, constructorDeclaration);
var indentation = IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps + 1);
var newColonTrailingTrivia = constructorInitializer.ColonToken.TrailingTrivia.WithoutTrailingWhitespace();
var newColonToken = constructorInitializer.ColonToken
.WithLeadingTrivia(indentation)
.WithTrailingTrivia(newColonTrailingTrivia);
var newInitializer = constructorInitializer
.WithColonToken(newColonToken)
.WithThisOrBaseKeyword(constructorInitializer.ThisOrBaseKeyword.WithLeadingTrivia(SyntaxFactory.Space));
return constructorDeclaration
.WithParameterList(newParameterList)
.WithInitializer(newInitializer);
}
private static SyntaxNode MoveMember(SyntaxNode syntaxRoot, MemberDeclarationSyntax member, MemberDeclarationSyntax targetMember, IndentationOptions indentationOptions)
{
var firstToken = syntaxRoot.GetFirstToken();
var fileHeader = GetFileHeader(firstToken.LeadingTrivia);
syntaxRoot = syntaxRoot.TrackNodes(member, targetMember, firstToken.Parent);
var memberToMove = syntaxRoot.GetCurrentNode(member);
var targetMemberTracked = syntaxRoot.GetCurrentNode(targetMember);
if (!memberToMove.HasLeadingTrivia)
{
var targetIndentationLevel = IndentationHelper.GetIndentationSteps(indentationOptions, targetMember);
var indentationString = IndentationHelper.GenerateIndentationString(indentationOptions, targetIndentationLevel);
memberToMove = memberToMove.WithLeadingTrivia(SyntaxFactory.Whitespace(indentationString));
}
if (!HasLeadingBlankLines(targetMember)
&& HasLeadingBlankLines(member))
{
memberToMove = memberToMove.WithTrailingTrivia(memberToMove.GetTrailingTrivia().Add(SyntaxFactory.CarriageReturnLineFeed));
memberToMove = memberToMove.WithLeadingTrivia(GetLeadingTriviaWithoutLeadingBlankLines(memberToMove));
}
syntaxRoot = syntaxRoot.InsertNodesBefore(targetMemberTracked, new[] { memberToMove });
var fieldToMoveTracked = syntaxRoot.GetCurrentNodes(member).Last();
syntaxRoot = syntaxRoot.RemoveNode(fieldToMoveTracked, SyntaxRemoveOptions.KeepNoTrivia);
if (fileHeader.Any())
{
var oldFirstToken = syntaxRoot.GetCurrentNode(firstToken.Parent).ChildTokens().First();
syntaxRoot = syntaxRoot.ReplaceToken(oldFirstToken, oldFirstToken.WithLeadingTrivia(StripFileHeader(oldFirstToken.LeadingTrivia)));
var newFirstToken = syntaxRoot.GetFirstToken();
syntaxRoot = syntaxRoot.ReplaceToken(newFirstToken, newFirstToken.WithLeadingTrivia(fileHeader.AddRange(newFirstToken.LeadingTrivia)));
}
return syntaxRoot;
}
private static SyntaxNode HandleNamespaceDeclaration(MemberOrderHelper memberOrder, NamespaceDeclarationSyntax namespaceDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
return OrderMember(memberOrder, namespaceDeclaration.Members, checks, syntaxRoot, indentationOptions);
}
private static SyntaxNode OrderMember(MemberOrderHelper memberOrder, SyntaxList<MemberDeclarationSyntax> members, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
var memberIndex = members.IndexOf(memberOrder.Member);
MemberOrderHelper target = default(MemberOrderHelper);
for (var i = memberIndex - 1; i >= 0; --i)
{
var orderHelper = new MemberOrderHelper(members[i], checks);
if (orderHelper.Priority < memberOrder.Priority)
{
target = orderHelper;
}
else
{
break;
}
}
return target.Member != null ? MoveMember(syntaxRoot, memberOrder.Member, target.Member, indentationOptions) : syntaxRoot;
}
private static SyntaxNode HandleTypeDeclaration(MemberOrderHelper memberOrder, TypeDeclarationSyntax typeDeclarationNode, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
return OrderMember(memberOrder, typeDeclarationNode.Members, checks, syntaxRoot, indentationOptions);
}
private static SyntaxNode HandleCompilationUnitDeclaration(MemberOrderHelper memberOrder, CompilationUnitSyntax compilationUnitDeclaration, ElementOrderingChecks checks, SyntaxNode syntaxRoot, IndentationOptions indentationOptions)
{
return OrderMember(memberOrder, compilationUnitDeclaration.Members, checks, syntaxRoot, indentationOptions);
}
/// <summary>
/// Generates a whitespace trivia with the requested indentation.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="indentationSteps">The amount of indentation steps.</param>
/// <returns>A <see cref="SyntaxTrivia"/> containing the indentation whitespace.</returns>
public static SyntaxTrivia GenerateWhitespaceTrivia(IndentationOptions indentationOptions, int indentationSteps)
{
return(SyntaxFactory.Whitespace(GenerateIndentationString(indentationOptions, indentationSteps)));
}
/// <summary>
/// Gets the number of steps that the given node is indented.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="node">The node to inspect.</param>
/// <returns>The number of steps that the node is indented.</returns>
public static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxNode node)
{
return GetIndentationSteps(indentationOptions, node.GetLeadingTrivia());
}
/// <summary>
/// Gets the number of steps that the given token is indented.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="token">The token to inspect.</param>
/// <returns>The number of steps that the token is indented.</returns>
public static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxToken token)
{
return GetIndentationSteps(indentationOptions, token.LeadingTrivia);
}
/// <summary>
/// Gets the number of steps that the given token is indented.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="token">The token to inspect.</param>
/// <returns>The number of steps that the token is indented.</returns>
public static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxToken token)
{
return(GetIndentationSteps(indentationOptions, token.LeadingTrivia));
}
private static SyntaxNode ReformatAccessorAsMultipleLines(IndentationOptions indentationOptions, AccessorDeclarationSyntax accessor)
{
var accessorList = (AccessorListSyntax)accessor.Parent;
var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, accessorList.OpenBraceToken) + 1;
var indentation = IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps);
var indentationStatements = IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps + 1);
var newAccessor = accessor
.WithModifiers(ReformatModifiersAsMultipleLines(accessor.Modifiers, indentation))
.WithKeyword(ReformatKeywordAsMultipleLines(accessor.Keyword, indentation, accessor.Modifiers.Count == 0))
.WithBody(ReformatBodyAsMultipleLines(accessor.Body, indentation, indentationStatements));
return newAccessor;
}
private static SyntaxNode ReformatAccessorAsSingleLine(IndentationOptions indentationOptions, AccessorDeclarationSyntax accessor)
{
var newAccessor = accessor
.WithModifiers(ReformatModifiersAsSingleLine(accessor.Modifiers))
.WithKeyword(ReformatKeywordAsSingleLine(accessor.Keyword))
.WithBody(ReformatBodyAsSingleLine(accessor.Body));
var accessorList = (AccessorListSyntax)accessor.Parent;
var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, accessorList.OpenBraceToken);
var indentation = IndentationHelper.GenerateWhitespaceTrivia(indentationOptions, indentationSteps + 1);
newAccessor = newAccessor.WithLeadingTrivia(newAccessor.GetLeadingTrivia().Insert(0, indentation));
return newAccessor;
}
private static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxTriviaList leadingTrivia)
{
var indentationString = string.Empty;
for (var i = leadingTrivia.Count - 1; (i >= 0) && leadingTrivia[i].IsKind(SyntaxKind.WhitespaceTrivia); i--)
{
indentationString = string.Concat(leadingTrivia[i].ToFullString(), indentationString);
}
var indentationCount = indentationString.ToCharArray().Sum(c => IndentationAmount(c, indentationOptions));
return indentationCount / indentationOptions.IndentationSize;
}
/// <summary>
/// Generates a whitespace trivia with the requested indentation.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="indentationSteps">The amount of indentation steps.</param>
/// <returns>A <see cref="SyntaxTrivia"/> containing the indentation whitespace.</returns>
public static SyntaxTrivia GenerateWhitespaceTrivia(IndentationOptions indentationOptions, int indentationSteps)
{
return SyntaxFactory.Whitespace(GenerateIndentationString(indentationOptions, indentationSteps));
}
private static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxTriviaList leadingTrivia)
{
SyntaxTriviaList.Reversed reversed = leadingTrivia.Reverse();
int indentationCount = 0;
foreach (SyntaxTrivia trivia in reversed)
{
if (!trivia.IsKind(SyntaxKind.WhitespaceTrivia))
{
break;
}
foreach (char c in trivia.ToFullString())
{
indentationCount += c == '\t' ? indentationOptions.TabSize : 1;
}
}
return indentationCount / indentationOptions.IndentationSize;
}
/// <summary>
/// Gets the number of steps that the given node is indented.
/// </summary>
/// <param name="indentationOptions">The indentation options to use.</param>
/// <param name="node">The node to inspect.</param>
/// <returns>The number of steps that the node is indented.</returns>
public static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxNode node)
{
return(GetIndentationSteps(indentationOptions, node.GetLeadingTrivia()));
}
private static int IndentationAmount(char c, IndentationOptions indentationOptions)
{
return(c == '\t' ? indentationOptions.TabSize : 1);
}
private static void BuildReplaceMapForConditionalDirectives(UsingsHelper usingsHelper, Dictionary<UsingDirectiveSyntax, UsingDirectiveSyntax> replaceMap, IndentationOptions indentationOptions, DirectiveSpan rootSpan)
{
foreach (var childSpan in rootSpan.Children)
{
var originalUsings = usingsHelper.GetContainedUsings(childSpan);
if (originalUsings.Count > 0)
{
// sort the original using declarations on Span.Start, in order to have the correct replace mapping.
originalUsings.Sort(CompareSpanStart);
var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, originalUsings[0].Parent);
if (originalUsings[0].Parent is NamespaceDeclarationSyntax)
{
indentationSteps++;
}
var indentation = IndentationHelper.GenerateIndentationString(indentationOptions, indentationSteps);
var modifiedUsings = usingsHelper.GenerateGroupedUsings(childSpan, indentation, false);
for (var i = 0; i < originalUsings.Count; i++)
{
replaceMap.Add(originalUsings[i], modifiedUsings[i]);
}
}
BuildReplaceMapForConditionalDirectives(usingsHelper, replaceMap, indentationOptions, childSpan);
}
}
private SyntaxNode RegisterBaseTypeDeclarationCodeFix(SyntaxNode syntaxRoot, BaseTypeDeclarationSyntax node, IndentationOptions indentationOptions)
{
return this.ReformatElement(syntaxRoot, node, node.OpenBraceToken, node.CloseBraceToken, indentationOptions);
}
private static void BuildReplaceMapForNamespaces(UsingsHelper usingsHelper, Dictionary<UsingDirectiveSyntax, UsingDirectiveSyntax> replaceMap, IndentationOptions indentationOptions)
{
var usingsPerNamespace = usingsHelper
.GetContainedUsings(usingsHelper.RootSpan)
.GroupBy(ud => ud.Parent)
.Select(gr => gr.ToList());
foreach (var usingList in usingsPerNamespace)
{
if (usingList.Count > 0)
{
// sort the original using declarations on Span.Start, in order to have the correct replace mapping.
usingList.Sort(CompareSpanStart);
var indentationSteps = IndentationHelper.GetIndentationSteps(indentationOptions, usingList[0].Parent);
if (usingList[0].Parent is NamespaceDeclarationSyntax)
{
indentationSteps++;
}
var indentation = IndentationHelper.GenerateIndentationString(indentationOptions, indentationSteps);
var modifiedUsings = usingsHelper.GenerateGroupedUsings(usingList, indentation, false);
for (var i = 0; i < usingList.Count; i++)
{
replaceMap.Add(usingList[i], modifiedUsings[i]);
}
}
}
}
private static int IndentationAmount(char c, IndentationOptions indentationOptions)
{
return c == '\t' ? indentationOptions.TabSize : 1;
}
private SyntaxNode ReformatElement(SyntaxNode syntaxRoot, SyntaxNode element, SyntaxToken openBraceToken, SyntaxToken closeBraceToken, IndentationOptions indentationOptions)
{
var tokenSubstitutions = new Dictionary<SyntaxToken, SyntaxToken>();
var parentLastToken = openBraceToken.GetPreviousToken();
var parentEndLine = parentLastToken.GetLineSpan().EndLinePosition.Line;
var blockStartLine = openBraceToken.GetLineSpan().StartLinePosition.Line;
// reformat parent if it is on the same line as the block.
if (parentEndLine == blockStartLine)
{
var newTrailingTrivia = parentLastToken.TrailingTrivia
.WithoutTrailingWhitespace()
.Add(SyntaxFactory.CarriageReturnLineFeed);
tokenSubstitutions.Add(parentLastToken, parentLastToken.WithTrailingTrivia(newTrailingTrivia));
}
var parentIndentationLevel = IndentationHelper.GetIndentationSteps(indentationOptions, element);
var indentationString = IndentationHelper.GenerateIndentationString(indentationOptions, parentIndentationLevel);
var contentIndentationString = IndentationHelper.GenerateIndentationString(indentationOptions, parentIndentationLevel + 1);
// reformat opening brace
tokenSubstitutions.Add(openBraceToken, this.FormatBraceToken(openBraceToken, indentationString));
// reformat start of content
var startOfContentToken = openBraceToken.GetNextToken();
if (startOfContentToken != closeBraceToken)
{
var newStartOfContentTokenLeadingTrivia = startOfContentToken.LeadingTrivia
.WithoutTrailingWhitespace()
.Add(SyntaxFactory.Whitespace(contentIndentationString));
tokenSubstitutions.Add(startOfContentToken, startOfContentToken.WithLeadingTrivia(newStartOfContentTokenLeadingTrivia));
}
// reformat end of content
var endOfContentToken = closeBraceToken.GetPreviousToken();
if (endOfContentToken != openBraceToken)
{
var newEndOfContentTokenTrailingTrivia = endOfContentToken.TrailingTrivia
.WithoutTrailingWhitespace()
.Add(SyntaxFactory.CarriageReturnLineFeed);
// check if the token already exists (occurs when there is only one token in the block)
if (tokenSubstitutions.ContainsKey(endOfContentToken))
{
tokenSubstitutions[endOfContentToken] = tokenSubstitutions[endOfContentToken].WithTrailingTrivia(newEndOfContentTokenTrailingTrivia);
}
else
{
tokenSubstitutions.Add(endOfContentToken, endOfContentToken.WithTrailingTrivia(newEndOfContentTokenTrailingTrivia));
}
}
// reformat closing brace
tokenSubstitutions.Add(closeBraceToken, this.FormatBraceToken(closeBraceToken, indentationString));
var rewriter = new TokenRewriter(tokenSubstitutions);
var newSyntaxRoot = rewriter.Visit(syntaxRoot);
return newSyntaxRoot;
}
private static int GetIndentationSteps(IndentationOptions indentationOptions, SyntaxTree syntaxTree, SyntaxTriviaList leadingTrivia)
{
var triviaSpan = syntaxTree.GetLineSpan(leadingTrivia.FullSpan);
// There is no indentation when the leading trivia doesn't begin at the start of the line.
if ((triviaSpan.StartLinePosition == triviaSpan.EndLinePosition) && (triviaSpan.StartLinePosition.Character > 0))
{
return 0;
}
var builder = StringBuilderPool.Allocate();
foreach (SyntaxTrivia trivia in leadingTrivia.Reverse())
{
if (!trivia.IsKind(SyntaxKind.WhitespaceTrivia))
{
break;
}
builder.Insert(0, trivia.ToFullString());
}
var tabSize = indentationOptions.TabSize;
var indentationCount = 0;
for (var i = 0; i < builder.Length; i++)
{
indentationCount += builder[i] == '\t' ? tabSize - (indentationCount % tabSize) : 1;
}
StringBuilderPool.ReturnAndFree(builder);
return (indentationCount + (indentationOptions.IndentationSize / 2)) / indentationOptions.IndentationSize;
}
private SyntaxNode RegisterPropertyLikeDeclarationCodeFix(SyntaxNode syntaxRoot, BasePropertyDeclarationSyntax node, IndentationOptions indentationOptions)
{
return this.ReformatElement(syntaxRoot, node, node.AccessorList.OpenBraceToken, node.AccessorList.CloseBraceToken, indentationOptions);
}
private static int DetermineIndentationSteps(IndentationOptions indentationOptions, SyntaxToken token)
{
// For a closing curly bracket use the indentation of the corresponding opening curly bracket
if (token.IsKind(SyntaxKind.CloseBraceToken))
{
var depth = 1;
while (depth > 0)
{
token = token.GetPreviousToken();
switch (token.Kind())
{
case SyntaxKind.CloseBraceToken:
depth++;
break;
case SyntaxKind.OpenBraceToken:
depth--;
break;
}
}
}
var startLine = GetTokenStartLinePosition(token).Line;
while (!ContainsStartOfLine(token, startLine))
{
token = token.GetPreviousToken();
}
return IndentationHelper.GetIndentationSteps(indentationOptions, token);
}
