private static ConditionalExpressionSyntax CreateMultilineConditionalExpression(ConditionalExpressionSyntax conditionalExpression) { SyntaxTriviaList triviaList = SyntaxUtility.GetIndentTrivia(conditionalExpression.Parent).Add(CSharpFactory.IndentTrivia()); triviaList = triviaList.Insert(0, CSharpFactory.NewLineTrivia()); ParenthesizedExpressionSyntax condition = null; if (conditionalExpression.Condition.IsKind(SyntaxKind.ParenthesizedExpression)) { condition = (ParenthesizedExpressionSyntax)conditionalExpression.Condition; } else { condition = ParenthesizedExpression(conditionalExpression.Condition.WithoutTrailingTrivia()) .WithCloseParenToken(CreateTokenWithTrailingNewLine(SyntaxKind.CloseParenToken)); } return(ConditionalExpression( condition.WithoutTrailingTrivia(), conditionalExpression.WhenTrue.WithoutTrailingTrivia(), conditionalExpression.WhenFalse.WithoutTrailingTrivia()) .WithQuestionToken(CreateToken(SyntaxKind.QuestionToken, triviaList)) .WithColonToken(CreateToken(SyntaxKind.ColonToken, triviaList))); }
private static SyntaxToken CreateTokenWithTrailingNewLine(SyntaxKind kind) { return(Token( TriviaList(), kind, TriviaList(CSharpFactory.NewLineTrivia()))); }
private static InitializerExpressionSyntax GetMultilineInitializer(InitializerExpressionSyntax initializer) { SyntaxNode parent = initializer.Parent; if (parent.IsKind(SyntaxKind.ObjectCreationExpression) && !initializer.IsKind(SyntaxKind.CollectionInitializerExpression)) { return(initializer .WithExpressions( SeparatedList( initializer.Expressions.Select(expression => expression.WithLeadingTrivia(CSharpFactory.NewLineTrivia())))) .WithFormatterAnnotation()); } SyntaxTriviaList indent = SyntaxUtility.GetIndentTrivia(initializer); SyntaxTriviaList indent2 = indent.Add(CSharpFactory.IndentTrivia()); indent = indent.Insert(0, CSharpFactory.NewLineTrivia()); indent2 = indent2.Insert(0, CSharpFactory.NewLineTrivia()); return(initializer .WithExpressions( SeparatedList( initializer.Expressions.Select(expression => expression.WithLeadingTrivia(indent2)))) .WithOpenBraceToken(initializer.OpenBraceToken.WithLeadingTrivia(indent)) .WithCloseBraceToken(initializer.CloseBraceToken.WithLeadingTrivia(indent)) .WithFormatterAnnotation()); }
private static LambdaExpressionSyntax GetNewNode( LambdaExpressionSyntax lambda, ExpressionSyntax expression, ISymbol symbol) { BlockSyntax block = Block(GetStatement(expression, symbol)); block = block .WithCloseBraceToken( block.CloseBraceToken .WithLeadingTrivia(TriviaList(CSharpFactory.NewLineTrivia()))); switch (lambda.Kind()) { case SyntaxKind.SimpleLambdaExpression: { return(((SimpleLambdaExpressionSyntax)lambda) .WithBody(block)); } case SyntaxKind.ParenthesizedLambdaExpression: { return(((ParenthesizedLambdaExpressionSyntax)lambda) .WithBody(block)); } } return(lambda); }
public static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { StatementSyntax newStatement = statement .WithLeadingTrivia(statement.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())) .WithFormatterAnnotation(); if (statement.IsParentKind(SyntaxKind.Block)) { var block = (BlockSyntax)statement.Parent; if (block.IsSingleLine(includeExteriorTrivia: false)) { SyntaxTriviaList triviaList = block.CloseBraceToken.LeadingTrivia .Add(CSharpFactory.NewLineTrivia()); BlockSyntax newBlock = block .WithCloseBraceToken(block.CloseBraceToken.WithLeadingTrivia(triviaList)) .WithStatements(block.Statements.Replace(statement, newStatement)) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false)); } else { return(await document.ReplaceNodeAsync(statement, newStatement, cancellationToken).ConfigureAwait(false)); } } else { return(await document.ReplaceNodeAsync(statement, newStatement, cancellationToken).ConfigureAwait(false)); } }
private static Task <Document> RefactorAsync( Document document, SyntaxToken token, CancellationToken cancellationToken) { SyntaxToken newToken = token.AppendToTrailingTrivia(CSharpFactory.NewLineTrivia()); return(document.ReplaceTokenAsync(token, newToken, cancellationToken)); }
public static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken) { StatementSyntax newNode = statement .AppendToTrailingTrivia(CSharpFactory.NewLineTrivia()) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(statement, newNode, cancellationToken).ConfigureAwait(false)); }
public override SyntaxToken VisitToken(SyntaxToken token) { if (_separators.Contains(token)) { SyntaxTriviaList triviaList = token.TrailingTrivia; if (!triviaList.Contains(SyntaxKind.EndOfLineTrivia)) { return(token.WithTrailingTrivia(triviaList.TrimEnd().Add(CSharpFactory.NewLineTrivia()))); } } return(base.VisitToken(token)); }
private static AccessorListSyntax GetNewAccessorList(AccessorListSyntax accessorList) { if (accessorList.IsSingleLine(includeExteriorTrivia: false)) { SyntaxTriviaList triviaList = accessorList.CloseBraceToken.LeadingTrivia .Add(CSharpFactory.NewLineTrivia()); return(Remover.RemoveWhitespaceOrEndOfLine(accessorList) .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(triviaList))); } else { return(AccessorSyntaxRewriter.VisitNode(accessorList)); } }
public static async Task <Document> RefactorAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia(); int index = trailingTrivia.IndexOf(SyntaxKind.EndOfLineTrivia); SyntaxTriviaList newTrailingTrivia = trailingTrivia.Insert(index, CSharpFactory.NewLineTrivia()); StatementSyntax newStatement = statement.WithTrailingTrivia(newTrailingTrivia); return(await document.ReplaceNodeAsync(statement, newStatement, cancellationToken).ConfigureAwait(false)); }
public static async Task <Document> RefactorAsync( Document document, CompilationUnitSyntax compilationUnit, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); CompilationUnitSyntax newNode = compilationUnit .WithLeadingTrivia( compilationUnit .GetLeadingTrivia() .Insert(0, CSharpFactory.NewLineTrivia()) .Insert(0, HeaderTrivia)); root = root.ReplaceNode(compilationUnit, newNode); return(document.WithSyntaxRoot(root)); }
private static IEnumerable <StatementSyntax> GetNewNodes(StatementSyntax statement) { List <SyntaxTrivia> list = null; if (statement.Parent.IsKind(SyntaxKind.ElseClause)) { list = new List <SyntaxTrivia>() { CSharpFactory.NewLineTrivia() }; } else { list = statement.Parent.GetLeadingTrivia() .Reverse() .SkipWhile(f => f.IsKind(SyntaxKind.WhitespaceTrivia)) .Reverse() .ToList(); } if (statement.IsKind(SyntaxKind.Block)) { SyntaxList <StatementSyntax> .Enumerator en = ((BlockSyntax)statement).Statements.GetEnumerator(); if (en.MoveNext()) { list.AddRange(en.Current.GetLeadingTrivia()); yield return(en.Current.WithLeadingTrivia(list)); while (en.MoveNext()) { yield return(en.Current); } } } else { list.AddRange(statement.GetLeadingTrivia()); yield return(statement.WithLeadingTrivia(list)); } }
private static async Task <Document> FormatOnMultipleLinesAsync( Document document, BinaryExpressionSyntax condition, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxTriviaList triviaList = SyntaxFactory.TriviaList(CSharpFactory.NewLineTrivia()) .AddRange(SyntaxUtility.GetIndentTrivia(condition)) .Add(CSharpFactory.IndentTrivia()); var rewriter = new BinaryExpressioneSyntaxRewriter(triviaList); var newCondition = (ExpressionSyntax)rewriter.Visit(condition); root = root.ReplaceNode(condition, newCondition); return(document.WithSyntaxRoot(root)); }
private static async Task <Document> AddEmptyLineAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia(); int index = trailingTrivia.IndexOf(SyntaxKind.EndOfLineTrivia); SyntaxTriviaList newTrailingTrivia = trailingTrivia.Insert(index, CSharpFactory.NewLineTrivia()); StatementSyntax newStatement = statement.WithTrailingTrivia(newTrailingTrivia); SyntaxNode newRoot = root.ReplaceNode(statement, newStatement); return(document.WithSyntaxRoot(newRoot)); }
public static async Task <Document> RefactorAsync( Document document, AccessorDeclarationSyntax accessor, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); SyntaxToken closeBrace = accessor.Body.CloseBraceToken; AccessorDeclarationSyntax newAccessor = accessor .WithBody( accessor.Body.WithCloseBraceToken( closeBrace.WithLeadingTrivia( closeBrace.LeadingTrivia.Add(CSharpFactory.NewLineTrivia())))) .WithFormatterAnnotation(); root = root.ReplaceNode(accessor, newAccessor); return(document.WithSyntaxRoot(root)); }
private static async Task <Document> FormatExpressionChainOnMultipleLinesAsync( Document document, ImmutableArray <MemberAccessExpressionSyntax> expressions, CancellationToken cancellationToken = default(CancellationToken)) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); MemberAccessExpressionSyntax expression = expressions[0]; SyntaxTriviaList triviaList = SyntaxUtility.GetIndentTrivia(expression).Add(CSharpFactory.IndentTrivia()); triviaList = triviaList.Insert(0, CSharpFactory.NewLineTrivia()); var rewriter = new ExpressionChainSyntaxRewriter(expressions, triviaList); SyntaxNode newNode = rewriter.Visit(expression) .WithFormatterAnnotation(); SyntaxNode newRoot = oldRoot.ReplaceNode(expression, newNode); return(document.WithSyntaxRoot(newRoot)); }
private static EventDeclarationSyntax ExpandEvent(EventFieldDeclarationSyntax eventDeclaration) { AccessorListSyntax accessorList = AccessorList( List(new AccessorDeclarationSyntax[] { AccessorDeclaration(SyntaxKind.AddAccessorDeclaration, Block()), AccessorDeclaration(SyntaxKind.RemoveAccessorDeclaration, Block()), })); accessorList = SyntaxRemover.RemoveWhitespaceOrEndOfLine(accessorList) .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia())); VariableDeclaratorSyntax declarator = eventDeclaration.Declaration.Variables[0]; return(EventDeclaration( eventDeclaration.AttributeLists, eventDeclaration.Modifiers, eventDeclaration.Declaration.Type, null, declarator.Identifier, accessorList)); }
private static PropertyDeclarationSyntax ExpandProperty(PropertyDeclarationSyntax propertyDeclaration) { AccessorListSyntax accessorList = AccessorList(List(CreateAccessors(propertyDeclaration))); accessorList = Remover.RemoveWhitespaceOrEndOfLine(accessorList) .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia())); return(propertyDeclaration .WithoutInitializer() .WithoutSemicolonToken() .WithAccessorList(accessorList)); }
public static Task <Document> RefactorAsync( Document document, MemberDeclarationSyntax memberDeclaration, CancellationToken cancellationToken) { MemberDeclarationSyntax newNode = memberDeclaration .WithTrailingTrivia(memberDeclaration.GetTrailingTrivia().Add(CSharpFactory.NewLineTrivia())); return(document.ReplaceNodeAsync(memberDeclaration, newNode, cancellationToken)); }
private static async Task <Document> AddEmptyLineAsync( Document document, MemberDeclarationSyntax declaration, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); MemberDeclarationSyntax newNode = declaration .WithTrailingTrivia(declaration.GetTrailingTrivia().Add(CSharpFactory.NewLineTrivia())); SyntaxNode newRoot = oldRoot.ReplaceNode(declaration, newNode); return(document.WithSyntaxRoot(newRoot)); }
private static MemberDeclarationSyntax GetNewDeclaration(MemberDeclarationSyntax declaration) { switch (declaration.Kind()) { case SyntaxKind.ClassDeclaration: { var classDeclaration = (ClassDeclarationSyntax)declaration; return(classDeclaration .WithOpenBraceToken(classDeclaration.OpenBraceToken.WithoutTrailingTrivia()) .WithCloseBraceToken(classDeclaration.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia()))); } case SyntaxKind.StructDeclaration: { var structDeclaration = (StructDeclarationSyntax)declaration; return(structDeclaration .WithOpenBraceToken(structDeclaration.OpenBraceToken.WithoutTrailingTrivia()) .WithCloseBraceToken(structDeclaration.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia()))); } case SyntaxKind.InterfaceDeclaration: { var interfaceDeclaration = (InterfaceDeclarationSyntax)declaration; return(interfaceDeclaration .WithOpenBraceToken(interfaceDeclaration.OpenBraceToken.WithoutTrailingTrivia()) .WithCloseBraceToken(interfaceDeclaration.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia()))); } } return(declaration); }
private static SyntaxNode Refactor(MemberDeclarationSyntax member) { switch (member.Parent.Kind()) { case SyntaxKind.CompilationUnit: { var parent = (CompilationUnitSyntax)member.Parent; int index = parent.Members.IndexOf(member); return(parent.WithMembers(parent.Members.Insert(index + 1, member))); } case SyntaxKind.NamespaceDeclaration: { var parent = (NamespaceDeclarationSyntax)member.Parent; int index = parent.Members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())); } return(parent.WithMembers(parent.Members.Insert(index + 1, member))); } case SyntaxKind.ClassDeclaration: { var parent = (ClassDeclarationSyntax)member.Parent; int index = parent.Members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())); } return(parent.WithMembers(parent.Members.Insert(index + 1, member))); } case SyntaxKind.StructDeclaration: { var parent = (StructDeclarationSyntax)member.Parent; int index = parent.Members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())); } return(parent.WithMembers(parent.Members.Insert(index + 1, member))); } case SyntaxKind.InterfaceDeclaration: { var parent = (InterfaceDeclarationSyntax)member.Parent; int index = parent.Members.IndexOf(member); if (index == 0 && parent.OpenBraceToken.GetFullSpanEndLine() == member.GetFullSpanStartLine()) { member = member.WithLeadingTrivia(member.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())); } return(parent.WithMembers(parent.Members.Insert(index + 1, member))); } } return(null); }
private static async Task <Document> DuplicateStatementAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken = default(CancellationToken)) { var block = (BlockSyntax)statement.Parent; int index = block.Statements.IndexOf(statement); if (index == 0 && block.OpenBraceToken.GetFullSpanEndLine() == statement.GetFullSpanStartLine()) { statement = statement.WithLeadingTrivia(statement.GetLeadingTrivia().Insert(0, CSharpFactory.NewLineTrivia())); } BlockSyntax newBlock = block.WithStatements(block.Statements.Insert(index + 1, statement)); return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false)); }
private static PropertyDeclarationSyntax ExpandPropertyAndAddBackingField(PropertyDeclarationSyntax propertyDeclaration, string name) { AccessorDeclarationSyntax getter = propertyDeclaration.Getter(); if (getter != null) { AccessorDeclarationSyntax newGetter = getter .WithBody(Block(ReturnStatement(IdentifierName(name)))) .WithoutSemicolonToken(); propertyDeclaration = propertyDeclaration .ReplaceNode(getter, newGetter) .WithoutInitializer() .WithoutSemicolonToken(); } AccessorDeclarationSyntax setter = propertyDeclaration.Setter(); if (setter != null) { AccessorDeclarationSyntax newSetter = setter .WithBody(Block( ExpressionStatement( SimpleAssignmentExpression( IdentifierName(name), IdentifierName("value"))))) .WithoutSemicolonToken(); propertyDeclaration = propertyDeclaration.ReplaceNode(setter, newSetter); } AccessorListSyntax accessorList = SyntaxRemover.RemoveWhitespaceOrEndOfLine(propertyDeclaration.AccessorList) .WithCloseBraceToken(propertyDeclaration.AccessorList.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia())); return(propertyDeclaration .WithAccessorList(accessorList)); }
public static Task <Document> RefactorAsync( Document document, BlockSyntax block, CancellationToken cancellationToken) { BlockSyntax newBlock = block .WithOpenBraceToken(block.OpenBraceToken.WithoutTrailingTrivia()) .WithCloseBraceToken(block.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia())) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(block, newBlock, cancellationToken)); }
private static async Task <Document> FormatBlockAsync( Document document, BlockSyntax block, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); BlockSyntax newBlock = block .WithOpenBraceToken(block.OpenBraceToken.WithoutTrailingTrivia()) .WithCloseBraceToken(block.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia())) .WithFormatterAnnotation(); SyntaxNode newRoot = oldRoot.ReplaceNode(block, newBlock); return(document.WithSyntaxRoot(newRoot)); }
private static async Task <Document> AddEmptyLineAfterEmbeddedStatementAsync( Document document, StatementSyntax node, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); StatementSyntax newNode = node .WithTrailingTrivia(node.GetTrailingTrivia().Add(CSharpFactory.NewLineTrivia())) .WithFormatterAnnotation(); SyntaxNode newRoot = oldRoot.ReplaceNode(node, newNode); return(document.WithSyntaxRoot(newRoot)); }
private static AccessorListSyntax CreateAccessorList(BlockSyntax block, bool singleline) { AccessorListSyntax accessorList = AccessorList( SingletonList( AccessorDeclaration( SyntaxKind.GetAccessorDeclaration, block))); if (singleline) { accessorList = SyntaxRemover.RemoveWhitespaceOrEndOfLine(accessorList) .WithCloseBraceToken(accessorList.CloseBraceToken.WithLeadingTrivia(CSharpFactory.NewLineTrivia())); } return(accessorList); }
public static SyntaxToken WithTrailingNewLine(this SyntaxToken token) { return(token.WithTrailingTrivia(CSharpFactory.NewLineTrivia())); }