private static UsingStatementSyntax CreateUsingStatement(StatementSyntax statement, BlockSyntax block) { return(SyntaxFactory.UsingStatement(block) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); }
SyntaxNode AddWatchNode(StatementSyntax node, ExpressionSyntax expr) { var id = Guid.NewGuid().ToString(); var c = node.GetTrailingTrivia().First(t => t.Kind() == SyntaxKind.SingleLineCommentTrivia && t.ToString().StartsWith("//=", StringComparison.InvariantCultureIgnoreCase)); var p = c.GetLocation().GetLineSpan().StartLinePosition; var wv = new WatchVariable { Id = id, Expression = expr.ToString(), ExplicitExpression = "", FilePath = path, FileLine = p.Line + 1, // 0-based index FileColumn = p.Character + 1, // 0-based index }; WatchVariables.Add(wv); var wi = GetWatchInstrument(id, expr); // creating a block and removing the open/close braces is a bit of a hack but // lets us replace one node with two... return (SyntaxFactory .Block(node, wi) .WithOpenBraceToken(SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken)) .WithCloseBraceToken(SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken)) .WithTrailingTrivia(SyntaxFactory.EndOfLine("\r\n"))); }
public override SyntaxNode VisitDoStatement(DoStatementSyntax node) { node = (DoStatementSyntax)base.VisitDoStatement(node); if (transformKind == TransformKind.DoToWhile) { // Get the different syntax nodes components of the Do Statement SyntaxToken doKeyword = node.DoKeyword; StatementSyntax doStatement = node.Statement; SyntaxToken whileKeyword = node.WhileKeyword; ExpressionSyntax condition = node.Condition; SyntaxToken openParen = node.OpenParenToken; SyntaxToken closeParen = node.CloseParenToken; SyntaxToken semicolon = node.SemicolonToken; // Preserve some level of trivia that was in the original Do keyword node. SyntaxToken newWhileKeyword = SyntaxFactory.Token(doKeyword.LeadingTrivia, SyntaxKind.WhileKeyword, whileKeyword.TrailingTrivia); // Preserve some level of trivia that was in the original Do keyword node and the original CloseParen token. List <SyntaxTrivia> newCloseParenTrivias = closeParen.TrailingTrivia.ToList(); newCloseParenTrivias.AddRange(doKeyword.TrailingTrivia.ToList()); SyntaxTriviaList newCloseParenTriviaList = SyntaxFactory.TriviaList(newCloseParenTrivias); SyntaxToken newCloseParen = SyntaxFactory.Token(closeParen.LeadingTrivia, SyntaxKind.CloseParenToken, newCloseParenTriviaList); List <SyntaxTrivia> newTrailingTrivias = doStatement.GetTrailingTrivia().ToList(); newTrailingTrivias.AddRange(semicolon.TrailingTrivia.ToList()); StatementSyntax newWhileStatement = doStatement.WithTrailingTrivia(newTrailingTrivias); return(SyntaxFactory.WhileStatement(newWhileKeyword, openParen, condition, newCloseParen, newWhileStatement)); } return(node); }
public override SyntaxNode VisitWhileStatement(WhileStatementSyntax node) { node = (WhileStatementSyntax)base.VisitWhileStatement(node); if (transformKind == TransformKind.WhileToDo) { // Get the different syntax nodes components of the While Statement SyntaxToken whileKeyword = node.WhileKeyword; SyntaxToken openParen = node.OpenParenToken; ExpressionSyntax condition = node.Condition; SyntaxToken closeParen = node.CloseParenToken; StatementSyntax whileStatement = node.Statement; // Preserve as much trivia and formatting info as possible while constructing the new nodes. SyntaxToken newDoKeyword = SyntaxFactory.Token(whileKeyword.LeadingTrivia, SyntaxKind.DoKeyword, closeParen.TrailingTrivia); SyntaxToken newWhileKeyword = SyntaxFactory.Token(SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker), SyntaxKind.WhileKeyword, whileKeyword.TrailingTrivia); SyntaxToken semiColonToken = SyntaxFactory.Token(SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker), SyntaxKind.SemicolonToken, whileStatement.GetTrailingTrivia()); SyntaxToken newCloseParen = SyntaxFactory.Token(closeParen.LeadingTrivia, SyntaxKind.CloseParenToken, SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker)); StatementSyntax newDoStatement = whileStatement.ReplaceTrivia(whileStatement.GetTrailingTrivia().Last(), SyntaxFactory.TriviaList()); return(SyntaxFactory.DoStatement(newDoKeyword, newDoStatement, newWhileKeyword, openParen, condition, newCloseParen, semiColonToken)); } return(node); }
private static void AnalyzeDoStatement(SyntaxNodeAnalysisContext context) { var doStatement = (DoStatementSyntax)context.Node; StatementSyntax statement = doStatement.Statement; if (!statement.IsKind(SyntaxKind.Block)) { return; } SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia(); if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia)) { return; } if (!doStatement.WhileKeyword.LeadingTrivia.IsEmptyOrWhitespace()) { return; } context.ReportDiagnostic( DiagnosticDescriptors.RemoveNewLineBetweenClosingBraceAndWhileKeyword, Location.Create(doStatement.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0))); }
private static Task <Document> RefactorAsync( Document document, StatementListInfo statementsInfo, StatementSyntax statement, InitializerExpressionSyntax initializer, ExpressionSyntax initializedExpression, CancellationToken cancellationToken) { ExpressionStatementSyntax[] expressions = CreateExpressionStatements(initializer, initializedExpression).ToArray(); expressions[expressions.Length - 1] = expressions[expressions.Length - 1] .WithTrailingTrivia(statement.GetTrailingTrivia()); var objectCreationExpression = (ObjectCreationExpressionSyntax)initializer.Parent; ObjectCreationExpressionSyntax newObjectCreationExpression = objectCreationExpression.WithInitializer(null); if (newObjectCreationExpression.ArgumentList == null) { TypeSyntax type = newObjectCreationExpression.Type; newObjectCreationExpression = newObjectCreationExpression .WithArgumentList(ArgumentList().WithTrailingTrivia(type.GetTrailingTrivia())) .WithType(type.WithoutTrailingTrivia()); } SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(statement); StatementSyntax newStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression); SyntaxKind statementKind = statement.Kind(); if (statementKind == SyntaxKind.ExpressionStatement) { var expressionStatement = (ExpressionStatementSyntax)newStatement; newStatement = expressionStatement .WithExpression(expressionStatement.Expression.WithoutTrailingTrivia()); } else if (statementKind == SyntaxKind.LocalDeclarationStatement) { var localDeclaration = (LocalDeclarationStatementSyntax)newStatement; newStatement = localDeclaration .WithDeclaration(localDeclaration.Declaration.WithoutTrailingTrivia()); } SyntaxList <StatementSyntax> newStatements = statements.Replace(statement, newStatement); SyntaxNode newNode = statementsInfo .WithStatements(newStatements.InsertRange(index + 1, expressions)) .Parent .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(statementsInfo.Parent, newNode, cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; StatementContainer container = StatementContainer.Create(localDeclaration); SyntaxList <StatementSyntax> statements = container.Statements; int index = statements.IndexOf(localDeclaration); StatementSyntax nextStatement = statements[index + 1]; var expressionStatement = (ExpressionStatementSyntax)nextStatement; var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression; ExpressionSyntax right = assignment.Right; EqualsValueClauseSyntax initializer = declarator.Initializer; ExpressionSyntax value = initializer?.Value; VariableDeclaratorSyntax newDeclarator = (value != null) ? declarator.ReplaceNode(value, right) : declarator.WithInitializer(EqualsValueClause(right)); LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator); SyntaxTriviaList trailingTrivia = localDeclaration.GetTrailingTrivia(); if (trailingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia())); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia()); } SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia(); if (leadingTrivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia())) { newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia)); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken)); }
public static Task <Document> RemoveRedundantAssignmentAfterLocalDeclarationAsync( Document document, VariableDeclaratorSyntax declarator, CancellationToken cancellationToken = default) { var declaration = (VariableDeclarationSyntax)declarator.Parent; var localDeclaration = (LocalDeclarationStatementSyntax)declaration.Parent; StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(localDeclaration); SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(localDeclaration); StatementSyntax nextStatement = statements[index + 1]; var expressionStatement = (ExpressionStatementSyntax)nextStatement; var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression; ExpressionSyntax right = assignment.Right; EqualsValueClauseSyntax initializer = declarator.Initializer; ExpressionSyntax value = initializer?.Value; VariableDeclaratorSyntax newDeclarator = (value != null) ? declarator.ReplaceNode(value, right) : declarator.WithInitializer(EqualsValueClause(right)); LocalDeclarationStatementSyntax newLocalDeclaration = localDeclaration.ReplaceNode(declarator, newDeclarator); SyntaxTriviaList trailingTrivia = localDeclaration.GetTrailingTrivia(); if (!trailingTrivia.IsEmptyOrWhitespace()) { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(trailingTrivia.Concat(nextStatement.GetTrailingTrivia())); } else { newLocalDeclaration = newLocalDeclaration.WithTrailingTrivia(nextStatement.GetTrailingTrivia()); } SyntaxTriviaList leadingTrivia = nextStatement.GetLeadingTrivia(); if (!leadingTrivia.IsEmptyOrWhitespace()) { newLocalDeclaration = newLocalDeclaration.WithLeadingTrivia(newLocalDeclaration.GetLeadingTrivia().Concat(leadingTrivia)); } SyntaxList <StatementSyntax> newStatements = statements .Replace(localDeclaration, newLocalDeclaration) .RemoveAt(index + 1); return(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); }
private static void Analyze( SyntaxNodeAnalysisContext context, StatementSyntax containingStatement, SyntaxToken token, StatementSyntax statement) { if (token.IsMissing) { return; } if (statement?.IsKind(SyntaxKind.Block, SyntaxKind.EmptyStatement) != false) { return; } if (!containingStatement.SyntaxTree.IsMultiLineSpan(TextSpan.FromBounds(token.SpanStart, statement.SpanStart))) { return; } SyntaxNode parent = containingStatement.Parent; if (parent?.Kind() != SyntaxKind.Block) { return; } var block = (BlockSyntax)parent; SyntaxList <StatementSyntax> statements = block.Statements; int index = statements.IndexOf(containingStatement); if (index == statements.Count - 1) { return; } if (containingStatement .SyntaxTree .GetLineCount(TextSpan.FromBounds(statement.Span.End, statements[index + 1].SpanStart)) > 2) { return; } SyntaxTrivia trivia = statement .GetTrailingTrivia() .FirstOrDefault(f => f.IsEndOfLineTrivia()); if (!trivia.IsEndOfLineTrivia()) { return; } context.ReportDiagnostic(DiagnosticDescriptors.AddEmptyLineAfterEmbeddedStatement, trivia); }
private static void Analyze( SyntaxNodeAnalysisContext context, StatementSyntax containingStatement, SyntaxToken token, StatementSyntax statement) { if (token.IsMissing) { return; } if (statement?.IsKind(SyntaxKind.Block, SyntaxKind.EmptyStatement) != false) { return; } StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(containingStatement); if (!statementsInfo.Success) { return; } SyntaxTree syntaxTree = containingStatement.SyntaxTree; if (!syntaxTree.IsMultiLineSpan(TextSpan.FromBounds(token.SpanStart, statement.SpanStart))) { return; } StatementSyntax nextStatement = containingStatement.NextStatement(); if (nextStatement == null) { return; } if (syntaxTree.GetLineCount(TextSpan.FromBounds(statement.Span.End, nextStatement.SpanStart)) > 2) { return; } SyntaxTrivia trivia = statement .GetTrailingTrivia() .FirstOrDefault(f => f.IsEndOfLineTrivia()); if (!trivia.IsEndOfLineTrivia()) { return; } DiagnosticHelpers.ReportDiagnostic( context, DiagnosticRules.AddEmptyLineAfterEmbeddedStatement, Location.Create(syntaxTree, trivia.Span.WithLength(0))); }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf <BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssingmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newAssignmentExpressions = new List <ExpressionStatementSyntax>(); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List <AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; initializationExpressions.Add(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right)); } var initializers = SyntaxFactory.SeparatedList <ExpressionSyntax>(initializationExpressions); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia("\n")), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return(newBlockParent); }
public static async Task <Solution> Replace(CodeRefactoringContext context, LocalDeclarationStatementSyntax localDeclarationStatement, StatementSyntax oldStatement) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); var localStatementWithTrivia = localDeclarationStatement .WithLeadingTrivia(oldStatement.GetLeadingTrivia()) .WithTrailingTrivia(oldStatement.GetTrailingTrivia()); var block = oldStatement.AncestorsAndSelf().OfType <BlockSyntax>().First(); var newRoot = root.ReplaceNode(block, block.ReplaceNode(oldStatement, localStatementWithTrivia)); var newDocument = context.Document.WithSyntaxRoot(newRoot); return(await LocalVariableRenamer.RenameVariable(newDocument, context)); }
private static SyntaxNode ProcessTemplates(List <AopTemplate> templates, StatementSyntax node, ClassDeclarationSyntax classDeclaration) { SyntaxNode result = node; string startingWhitespace = ""; if (node.HasLeadingTrivia) { startingWhitespace = node.GetLeadingTrivia().ToFullString(); } string closingWhitespace = ""; if (node.HasTrailingTrivia) { closingWhitespace = node.GetTrailingTrivia().ToFullString(); } var aopCsharpTemplateService = new AopCsharpTemplateService(); foreach (AopTemplate template in templates.OrderBy(o => o.AdvicePriority)) { Console.Out.WriteLine($"\tProcessing template {template.TemplateName}"); string sourceCode = aopCsharpTemplateService.ProcessTemplate(template.TemplateName, new Dictionary <string, object>() { { "ClassNode", classDeclaration }, { "MethodNode", result is MethodDeclarationSyntax ? result : null }, { "PropertyNode", result is PropertyDeclarationSyntax ? result : null }, { "StatementNode", result is StatementSyntax ? result : null }, { "ExtraTag", template.ExtraTag } }); // if sourceCode is null, it means no changes were done to original code and we keep it as-is if (sourceCode == null) { continue; } sourceCode = sourceCode.Trim(' ', '\r', '\n'); if (!Regex.IsMatch(sourceCode, "^\\s*\\{.*\\}\\s*$", RegexOptions.Singleline)) { sourceCode = (new StringBuilder()).AppendLine("{").AppendLine(sourceCode).AppendLine(startingWhitespace + "}").ToString(); } result = SyntaxFactory.ParseStatement(startingWhitespace + sourceCode + closingWhitespace); } return(result); }
private CodeAction CreateCodeAction(Document document, Diagnostic diagnostic, IfStatementSyntax ifStatement, StatementSyntax statement) { return(CodeAction.Create( Title, cancellationToken => { StatementSyntax newNode = statement .WithLeadingTrivia(ifStatement.GetLeadingTrivia().AddRange(statement.GetLeadingTrivia().EmptyIfWhitespace())) .WithTrailingTrivia(statement.GetTrailingTrivia().EmptyIfWhitespace().AddRange(ifStatement.GetTrailingTrivia())); return document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken); }, GetEquivalenceKey(diagnostic))); }
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)); }
private static async Task <Document> AddEmptyLineAfterEmbeddedStatementAsync( Document document, StatementSyntax node, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken); StatementSyntax newNode = node .WithTrailingTrivia(node.GetTrailingTrivia().Add(SyntaxHelper.NewLine)) .WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode newRoot = oldRoot.ReplaceNode(node, newNode); 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 Task <Document> AddEmptyLineBeforeWhileInDoStatementAsync( Document document, StatementSyntax statement, CancellationToken cancellationToken = default) { SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia(); int index = trailingTrivia.IndexOf(SyntaxKind.EndOfLineTrivia); SyntaxTriviaList newTrailingTrivia = trailingTrivia.Insert(index, CSharpFactory.NewLine()); StatementSyntax newStatement = statement.WithTrailingTrivia(newTrailingTrivia); return(document.ReplaceNodeAsync(statement, newStatement, cancellationToken)); }
private static SyntaxRemoveOptions GetRemoveOptions(StatementSyntax statement) { SyntaxRemoveOptions removeOptions = Remover.DefaultMemberRemoveOptions; if (statement.GetLeadingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia())) { removeOptions &= ~SyntaxRemoveOptions.KeepLeadingTrivia; } if (statement.GetTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia())) { removeOptions &= ~SyntaxRemoveOptions.KeepTrailingTrivia; } return(removeOptions); }
public static void Analyze(SyntaxNodeAnalysisContext context, DoStatementSyntax doStatement) { StatementSyntax statement = doStatement.Statement; if (statement?.IsKind(SyntaxKind.Block) == true) { var block = (BlockSyntax)statement; SyntaxList <StatementSyntax> statements = block.Statements; if (statements.Any()) { SyntaxToken closeBrace = block.CloseBraceToken; if (!closeBrace.IsMissing) { SyntaxToken whileKeyword = doStatement.WhileKeyword; if (!whileKeyword.IsMissing) { int closeBraceLine = closeBrace.GetSpanEndLine(); if (closeBraceLine == whileKeyword.GetSpanStartLine()) { StatementSyntax last = statements.Last(); int line = last.GetSpanEndLine(context.CancellationToken); if (closeBraceLine - line == 1) { SyntaxTrivia trivia = last .GetTrailingTrivia() .FirstOrDefault(f => f.IsEndOfLineTrivia()); if (trivia.IsKind(SyntaxKind.EndOfLineTrivia)) { context.ReportDiagnostic( DiagnosticDescriptors.AddEmptyLineAfterLastStatementInDoStatement, Location.Create(doStatement.SyntaxTree, trivia.Span)); } } } } } } } }
public static Task <Document> RefactorAsync( Document document, UnsafeStatementSyntax unsafeStatement, SyntaxNode containingNode, CancellationToken cancellationToken) { SyntaxToken keyword = unsafeStatement.UnsafeKeyword; BlockSyntax block = unsafeStatement.Block; SyntaxList <StatementSyntax> statements = block.Statements; SyntaxNode newNode = null; int count = statements.Count; if (count == 0) { newNode = containingNode.RemoveNode(unsafeStatement); } else { StatementSyntax first = statements.First(); StatementSyntax last = statements.Last(); SyntaxTriviaList leadingTrivia = keyword.LeadingTrivia .AddRange(keyword.TrailingTrivia.EmptyIfWhitespace()) .AddRange(block.GetLeadingTrivia().EmptyIfWhitespace()) .AddRange(block.OpenBraceToken.TrailingTrivia.EmptyIfWhitespace()) .AddRange(first.GetLeadingTrivia().EmptyIfWhitespace()); SyntaxTriviaList trailingTrivia = last.GetTrailingTrivia().EmptyIfWhitespace() .AddRange(block.CloseBraceToken.LeadingTrivia.EmptyIfWhitespace()) .AddRange(block.GetTrailingTrivia()); statements = statements .ReplaceAt(0, first.WithLeadingTrivia(leadingTrivia)) .ReplaceAt(count - 1, last.WithTrailingTrivia(trailingTrivia)); newNode = containingNode.ReplaceNode(unsafeStatement, statements.Select(f => f.WithFormatterAnnotation())); } newNode = newNode.InsertModifier(SyntaxKind.UnsafeKeyword); return(document.ReplaceNodeAsync(containingNode, newNode, cancellationToken)); }
private static async Task <Document> ExpandObjectInitializerAsync( Document document, InitializerExpressionSyntax initializer, StatementSyntax statement, ExpressionSyntax expression, CancellationToken cancellationToken) { SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken); ExpressionStatementSyntax[] expressions = ExpandObjectInitializer(initializer, expression).ToArray(); expressions[expressions.Length - 1] = expressions[expressions.Length - 1] .WithTrailingTrivia(statement.GetTrailingTrivia()); var block = (BlockSyntax)statement.Parent; int index = block.Statements.IndexOf(statement); StatementSyntax newStatement = statement.RemoveNode(initializer, SyntaxRemoveOptions.KeepNoTrivia); if (statement.IsKind(SyntaxKind.ExpressionStatement)) { var expressionStatement = (ExpressionStatementSyntax)newStatement; newStatement = expressionStatement .WithExpression(expressionStatement.Expression.WithoutTrailingTrivia()); } else if (statement.IsKind(SyntaxKind.LocalDeclarationStatement)) { var localDeclaration = (LocalDeclarationStatementSyntax)newStatement; newStatement = localDeclaration .WithDeclaration(localDeclaration.Declaration.WithoutTrailingTrivia()); } SyntaxList <StatementSyntax> newStatements = block.Statements.Replace(statement, newStatement); BlockSyntax newBlock = block .WithStatements(newStatements.InsertRange(index + 1, expressions)) .WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode newRoot = oldRoot.ReplaceNode(block, newBlock); return(document.WithSyntaxRoot(newRoot)); }
private static void AnalyzeDoStatement(SyntaxNodeAnalysisContext context) { var doStatement = (DoStatementSyntax)context.Node; StatementSyntax statement = doStatement.Statement; if (!statement.IsKind(SyntaxKind.Block)) { return; } NewLineStyle newLineStyle = context.GetNewLineBeforeWhileInDoStatement(); if (newLineStyle == NewLineStyle.None) { return; } SyntaxTriviaList trailingTrivia = statement.GetTrailingTrivia(); if (!trailingTrivia.Any() || trailingTrivia.SingleOrDefault(shouldThrow: false).IsWhitespaceTrivia()) { if (!doStatement.WhileKeyword.LeadingTrivia.Any() && newLineStyle == NewLineStyle.Add) { context.ReportDiagnostic( DiagnosticRules.AddOrRemoveNewLineBeforeWhileInDoStatement, Location.Create(doStatement.SyntaxTree, new TextSpan(statement.FullSpan.End, 0)), "Add"); } } else if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia)) { if (doStatement.WhileKeyword.LeadingTrivia.IsEmptyOrWhitespace() && newLineStyle == NewLineStyle.Remove) { context.ReportDiagnostic( DiagnosticRules.AddOrRemoveNewLineBeforeWhileInDoStatement, Location.Create(doStatement.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0)), properties: DiagnosticProperties.AnalyzerOption_Invert, "Remove"); } } }
private static async Task <Document> RefactorAsync( Document document, StatementContainer statementContainer, StatementSyntax statement, InitializerExpressionSyntax initializer, ExpressionSyntax expression, CancellationToken cancellationToken) { ExpressionStatementSyntax[] expressions = Refactor(initializer, expression).ToArray(); expressions[expressions.Length - 1] = expressions[expressions.Length - 1] .WithTrailingTrivia(statement.GetTrailingTrivia()); SyntaxList <StatementSyntax> statements = statementContainer.Statements; int index = statements.IndexOf(statement); StatementSyntax newStatement = statement.RemoveNode(initializer, SyntaxRemoveOptions.KeepNoTrivia); SyntaxKind statementKind = statement.Kind(); if (statementKind == SyntaxKind.ExpressionStatement) { var expressionStatement = (ExpressionStatementSyntax)newStatement; newStatement = expressionStatement .WithExpression(expressionStatement.Expression.WithoutTrailingTrivia()); } else if (statementKind == SyntaxKind.LocalDeclarationStatement) { var localDeclaration = (LocalDeclarationStatementSyntax)newStatement; newStatement = localDeclaration .WithDeclaration(localDeclaration.Declaration.WithoutTrailingTrivia()); } SyntaxList <StatementSyntax> newStatements = statements.Replace(statement, newStatement); SyntaxNode newNode = statementContainer .NodeWithStatements(newStatements.InsertRange(index + 1, expressions)) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(statementContainer.Node, newNode, cancellationToken).ConfigureAwait(false)); }
private async Task <Document> ReplaceBinaryAnd(Document document, InvocationExpressionSyntax invocationExpression, bool isIsTrue, SyntaxKind kind, CancellationToken cancellationToken) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken); ArgumentListSyntax arguments = invocationExpression.ArgumentList; BinaryExpressionSyntax expr = (BinaryExpressionSyntax)arguments.Arguments[0].Expression; var left = expr.Left; var right = expr.Right; ArgumentSyntax[] additionalArguments = arguments.Arguments.Skip(1).ToArray(); var leftAssert = CreateAssert(left, isIsTrue, additionalArguments); var rightAssert = CreateAssert(right, isIsTrue, additionalArguments); SyntaxNode node = invocationExpression; BlockSyntax parentBlock = null; while (parentBlock == null && node != null) { parentBlock = node.Parent as BlockSyntax; node = node.Parent; } int statementIndex = parentBlock.Statements.IndexOf(x => x.Contains(invocationExpression)); StatementSyntax statement = parentBlock.Statements[statementIndex]; var leadingTrivia = statement.GetLeadingTrivia(); var trailingTrivia = statement.GetTrailingTrivia(); var statements = parentBlock.Statements.Insert(statementIndex, rightAssert.WithLeadingTrivia().WithTrailingTrivia(trailingTrivia)); statements = statements.Insert(statementIndex, leftAssert.WithLeadingTrivia(leadingTrivia)); statements = statements.RemoveAt(statementIndex + 2); var newBlock = parentBlock.WithStatements(statements); root = root.ReplaceNode(parentBlock, newBlock); 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)); }
private static SyntaxList <StatementSyntax> RewriteStatements(SyntaxList <StatementSyntax> statements) { for (int i = statements.Count - 1; i >= 0; i--) { StatementSyntax statement = statements[i]; if (statement.HasAnnotation(_asyncAwaitAnnotation[0])) { statements = statements.Replace( statement, statement.WithoutAnnotations(_asyncAwaitAnnotation).WithTrailingTrivia(NewLine())); statements = statements.Insert( i + 1, ReturnStatement().WithTrailingTrivia(statement.GetTrailingTrivia()).WithFormatterAnnotation()); } } return(statements); }
private static void Analyze( SyntaxNodeAnalysisContext context, StatementSyntax containingStatement, SyntaxToken token, StatementSyntax statement) { if (!token.IsKind(SyntaxKind.None) && !token.IsMissing && statement?.IsKind(SyntaxKind.Block, SyntaxKind.EmptyStatement) == false && context.SyntaxTree().IsMultiLineSpan(TextSpan.FromBounds(token.SpanStart, statement.SpanStart))) { SyntaxNode parent = containingStatement.Parent; if (parent?.IsKind(SyntaxKind.Block) == true) { var block = (BlockSyntax)parent; SyntaxList <StatementSyntax> statements = block.Statements; int index = statements.IndexOf(containingStatement); if (index < statements.Count - 1 && context .SyntaxTree() .GetLineCount(TextSpan.FromBounds(statement.Span.End, statements[index + 1].SpanStart)) <= 2) { SyntaxTrivia trivia = statement .GetTrailingTrivia() .FirstOrDefault(f => f.IsEndOfLineTrivia()); if (trivia.IsEndOfLineTrivia()) { context.ReportDiagnostic( DiagnosticDescriptors.AddEmptyLineAfterEmbeddedStatement, trivia.GetLocation()); } } } } }
public static Task <Document> RefactorAsync( Document document, UnsafeStatementSyntax unsafeStatement, CancellationToken cancellationToken) { SyntaxToken keyword = unsafeStatement.UnsafeKeyword; BlockSyntax block = unsafeStatement.Block; SyntaxToken openBrace = block.OpenBraceToken; SyntaxToken closeBrace = block.CloseBraceToken; SyntaxList <StatementSyntax> statements = block.Statements; StatementSyntax firstStatement = statements.First(); IEnumerable <SyntaxTrivia> leadingTrivia = keyword .TrailingTrivia.EmptyIfWhitespace() .Concat(openBrace.LeadingTrivia.EmptyIfWhitespace()) .Concat(openBrace.TrailingTrivia.EmptyIfWhitespace()) .Concat(firstStatement.GetLeadingTrivia().EmptyIfWhitespace()); leadingTrivia = keyword.LeadingTrivia.AddRange(leadingTrivia); statements = statements.ReplaceAt(0, firstStatement.WithLeadingTrivia(leadingTrivia)); StatementSyntax lastStatement = statements.Last(); IEnumerable <SyntaxTrivia> trailingTrivia = lastStatement .GetTrailingTrivia().EmptyIfWhitespace() .Concat(closeBrace.LeadingTrivia.EmptyIfWhitespace()) .Concat(closeBrace.TrailingTrivia.EmptyIfWhitespace()); trailingTrivia = closeBrace.TrailingTrivia.InsertRange(0, trailingTrivia); statements = statements.ReplaceAt(statements.Count - 1, lastStatement.WithTrailingTrivia(trailingTrivia)); return(document.ReplaceNodeAsync(unsafeStatement, statements, cancellationToken)); }
public static async Task <Document> RefactorAsync( Document document, ElseClauseSyntax elseClause, CancellationToken cancellationToken) { if (elseClause.IsParentKind(SyntaxKind.IfStatement)) { var ifStatement = (IfStatementSyntax)elseClause.Parent; StatementSyntax statement = ifStatement.Statement; if (statement?.GetTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()) == true) { IfStatementSyntax newIfStatement = ifStatement .WithStatement(statement.WithTrailingTrivia(elseClause.GetTrailingTrivia())) .WithElse(null); return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false)); } } return(await document.RemoveNodeAsync(elseClause, SyntaxRemoveOptions.KeepExteriorTrivia, cancellationToken).ConfigureAwait(false)); }
private static UsingStatementSyntax CreateUsingStatement(StatementSyntax statement, BlockSyntax block) { return SyntaxFactory.UsingStatement(block) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf<BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssignmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newAssignmentExpressions = new List<ExpressionStatementSyntax>(); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List<AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; initializationExpressions.Add(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right)); } var initializers = SyntaxFactory.SeparatedList<ExpressionSyntax>(initializationExpressions); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia("\n")), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return newBlockParent; }
public static StatementSyntax Trivia(this StatementSyntax node, StatementSyntax that) { return node.WithLeadingTrivia(that.GetLeadingTrivia()).WithTrailingTrivia(that.GetTrailingTrivia()); }
SyntaxNode AddWatchNode(StatementSyntax node, ExpressionSyntax expr) { var id = Guid.NewGuid().ToString(); var c = node.GetTrailingTrivia().First(t => t.Kind() == SyntaxKind.SingleLineCommentTrivia && t.ToString().StartsWith("//=")); var p = c.GetLocation().GetLineSpan().StartLinePosition; var wv = new WatchVariable { Id = id, Expression = expr.ToString(), ExplicitExpression = "", FilePath = path, FileLine = p.Line + 1, // 0-based index FileColumn = p.Character + 1, // 0-based index }; WatchVariables.Add(wv); var wi = GetWatchInstrument(id, expr); // creating a block and removing the open/close braces is a bit of a hack but // lets us replace one node with two... return SyntaxFactory .Block(node, wi) .WithOpenBraceToken(SyntaxFactory.MissingToken(SyntaxKind.OpenBraceToken)) .WithCloseBraceToken(SyntaxFactory.MissingToken(SyntaxKind.CloseBraceToken)) .WithTrailingTrivia(SyntaxFactory.EndOfLine("\r\n")); }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf<BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssignmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List<AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; var newAssignmentExpression = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right); initializationExpressions.Add(newAssignmentExpression); } if (objectCreationExpression.Initializer != null) { var existentInitilizers = objectCreationExpression.Initializer.Expressions.Cast<AssignmentExpressionSyntax>() .Where(ae => { var propertyIdentifier = ae.Left.ToFullString().Trim(); return initializationExpressions.All(ie => ie.Left.ToFullString().Trim() != propertyIdentifier); }) .Select(ae => ae.WithoutTrivia()) .ToList(); initializationExpressions.InsertRange(0, existentInitilizers); } var initializers = SyntaxFactory.SeparatedList<ExpressionSyntax>(initializationExpressions); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); if (newObjectCreationExpression.ArgumentList?.Arguments.Count == 0) { newObjectCreationExpression = newObjectCreationExpression.WithArgumentList(null); } var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return newBlockParent; }
private static BlockSyntax CreateNewBlockParent(StatementSyntax statement, SemanticModel semanticModel, ObjectCreationExpressionSyntax objectCreationExpression, ISymbol variableSymbol) { var blockParent = statement.FirstAncestorOrSelf<BlockSyntax>(); var assignmentExpressions = ObjectInitializerAnalyzer.FindAssignmentExpressions(semanticModel, statement, variableSymbol); var newBlockParent = SyntaxFactory.Block() .WithLeadingTrivia(blockParent.GetLeadingTrivia()) .WithTrailingTrivia(blockParent.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); for (int i = 0; i < blockParent.Statements.Count; i++) { var blockStatement = blockParent.Statements[i]; if (blockStatement.Equals(statement)) { var initializationExpressions = new List<AssignmentExpressionSyntax>(); foreach (var expressionStatement in assignmentExpressions) { var assignmentExpression = expressionStatement.Expression as AssignmentExpressionSyntax; var memberAccess = assignmentExpression.Left as MemberAccessExpressionSyntax; var propertyIdentifier = memberAccess.Name as IdentifierNameSyntax; var newAssignmentExpression = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, propertyIdentifier, assignmentExpression.Right); initializationExpressions.Add(newAssignmentExpression.WithTriviaFrom(expressionStatement)); } if (objectCreationExpression.Initializer != null) { var existentInitilizers = objectCreationExpression.Initializer.Expressions.Cast<AssignmentExpressionSyntax>() .Where(ae => { var propertyIdentifier = ae.Left.ToFullString().Trim(); return initializationExpressions.All(ie => ie.Left.ToFullString().Trim() != propertyIdentifier); }) .Select(ae => ae.WithoutTrivia()) .ToList(); initializationExpressions.InsertRange(0, existentInitilizers); } // Trailing trivia will be added before the separator if a simple separator list is used. This builds the separator token for expression // such that the trailing trivia from the original expression is added after the comma on the same line. var initializerSeparators = initializationExpressions.Take(initializationExpressions.Count - 1).Select(expr => SyntaxFactory.Token(SyntaxKind.CommaToken).WithTrailingTrivia(expr.GetTrailingTrivia())).ToList(); var lastInitializer = initializationExpressions.Last(); // Preserve the last initializer before rebuilding the list. // Get all but the last initializer without the trailing trivia. Trivia will be added after the separator from the list above. initializationExpressions = initializationExpressions.Take(initializationExpressions.Count - 1).Select(expr => expr.WithoutTrailingTrivia()).ToList(); initializationExpressions.Add(lastInitializer); // Add the last initializer with all of its trivia. var initializers = SyntaxFactory.SeparatedList<ExpressionSyntax>(initializationExpressions, initializerSeparators); var newObjectCreationExpression = objectCreationExpression.WithInitializer( SyntaxFactory.InitializerExpression( SyntaxKind.ObjectInitializerExpression, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.OpenBraceToken, SyntaxFactory.ParseTrailingTrivia(Environment.NewLine)), initializers, SyntaxFactory.Token(SyntaxFactory.ParseLeadingTrivia(" "), SyntaxKind.CloseBraceToken, SyntaxFactory.ParseTrailingTrivia("")) )) .WithLeadingTrivia(objectCreationExpression.GetLeadingTrivia()) .WithTrailingTrivia(objectCreationExpression.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); if (newObjectCreationExpression.ArgumentList?.Arguments.Count == 0) { newObjectCreationExpression = newObjectCreationExpression.WithArgumentList(null); } var newLocalDeclarationStatement = statement.ReplaceNode(objectCreationExpression, newObjectCreationExpression) .WithLeadingTrivia(statement.GetLeadingTrivia()) .WithTrailingTrivia(statement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation); newBlockParent = newBlockParent.AddStatements(newLocalDeclarationStatement); i += initializationExpressions.Count; } else { newBlockParent = newBlockParent.AddStatements(blockStatement .WithLeadingTrivia(blockStatement.GetLeadingTrivia()) .WithTrailingTrivia(blockStatement.GetTrailingTrivia()) .WithAdditionalAnnotations(Formatter.Annotation)); } } return newBlockParent; }