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