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