/// <summary>
/// Recurrent function for removeing bagical number from last statement in given BlockSyntax.
/// </summary>
/// <param name="oldBlock">BlockSyntax in which a statement is defined</param>
/// <param name="root">Root in which a statement was defind orignally</param>
/// <returns>New BlockSyntax with removed magical number in a statement</returns>
private BlockSyntax RemoveMagicalNumber(BlockSyntax oldBlock, SyntaxNode root)
{
StatementSyntax node = oldBlock.Statements.Last();
// Find all magical numbers in a statement
var numericalNode = node.DescendantNodes()
.FirstOrDefault(n => n.IsKind(SyntaxKind.NumericLiteralExpression));
if (numericalNode != null)
{
var expresion = (LocalDeclarationStatementSyntax)SyntaxFactory
.ParseStatement($"var {FindFreeVariableName(root, oldBlock)} = {numericalNode.ToFullString()};")
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(SyntaxFactory
.ParseTrailingTrivia("\n"));
return(RemoveMagicalNumber(oldBlock.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia)
.AddStatements(expresion)
.AddStatements(node.ReplaceNode(numericalNode,
SyntaxFactory.IdentifierName(expresion.Declaration
.Variables[0]
.Identifier))),
root));
}
else
{
return(oldBlock);
}
}
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));
}
}
public static StatementSyntax AddIndention(StatementSyntax statementSyntax, int level)
{
IEnumerable <SyntaxTrivia> indention = statementSyntax.GetLeadingTrivia().ToList();
indention = AddIndention(level, indention);
return(statementSyntax.WithLeadingTrivia(indention));
}
private static UsingStatementSyntax CreateUsingStatement(StatementSyntax statement, BlockSyntax block)
{
return(SyntaxFactory.UsingStatement(block)
.WithLeadingTrivia(statement.GetLeadingTrivia())
.WithTrailingTrivia(statement.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation));
}
private BlockSyntax ToBlockSyntax(StatementSyntax body, SyntaxTriviaList leading, SyntaxTriviaList trailing)
{
//TODO: fix trivia
var bracketLeadingTrivia = leading.Insert(0, SyntaxFactory.EndOfLine(Environment.NewLine));
List <StatementSyntax> statements = new List <StatementSyntax>();
if (body.Kind() == SyntaxKind.Block)
{
body = (StatementSyntax)Visit(body);
return((BlockSyntax)body);
}
else
{
var leadingTrivia = body.GetLeadingTrivia();
body = (StatementSyntax)Visit(body);
statements.Add(body);
}
BlockSyntax block = SyntaxFactory.Block(statements);
block = block.WithOpenBraceToken(
SyntaxFactory.Token(SyntaxKind.OpenBraceToken)
.WithLeadingTrivia(bracketLeadingTrivia)
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine))
);
block = block.WithCloseBraceToken(SyntaxFactory.Token(SyntaxKind.CloseBraceToken).
WithLeadingTrivia(bracketLeadingTrivia).
WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine)));
return(block);
}
private static ExpressionSyntax TryGetExpression(StatementSyntax firstStatement)
{
if (firstStatement.Kind() == SyntaxKind.ExpressionStatement)
{
return ((ExpressionStatementSyntax)firstStatement).Expression;
}
else if (firstStatement.Kind() == SyntaxKind.ReturnStatement)
{
var returnStatement = (ReturnStatementSyntax)firstStatement;
if (returnStatement.Expression != null)
{
// If there are any comments on the return keyword, move them to
// the expression.
return firstStatement.GetLeadingTrivia().Any(t => t.IsSingleOrMultiLineComment())
? returnStatement.Expression.WithLeadingTrivia(returnStatement.GetLeadingTrivia())
: returnStatement.Expression;
}
}
else if (firstStatement.Kind() == SyntaxKind.ThrowStatement)
{
var throwStatement = (ThrowStatementSyntax)firstStatement;
if (throwStatement.Expression != null)
{
return SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);
}
}
return null;
}
private static ExpressionSyntax TryGetExpression(StatementSyntax firstStatement)
{
if (firstStatement.Kind() == SyntaxKind.ExpressionStatement)
{
return(((ExpressionStatementSyntax)firstStatement).Expression);
}
else if (firstStatement.Kind() == SyntaxKind.ReturnStatement)
{
var returnStatement = (ReturnStatementSyntax)firstStatement;
if (returnStatement.Expression != null)
{
// If there are any comments on the return keyword, move them to
// the expression.
return(firstStatement.GetLeadingTrivia().Any(t => t.IsSingleOrMultiLineComment())
? returnStatement.Expression.WithLeadingTrivia(returnStatement.GetLeadingTrivia())
: returnStatement.Expression);
}
}
else if (firstStatement.Kind() == SyntaxKind.ThrowStatement)
{
var throwStatement = (ThrowStatementSyntax)firstStatement;
if (throwStatement.Expression != null)
{
return(SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression));
}
}
return(null);
}
private static void AnalyzeElseClause(SyntaxNodeAnalysisContext context)
{
var elseClause = (ElseClauseSyntax)context.Node;
StatementSyntax statement = elseClause.Statement;
if (!statement.IsKind(SyntaxKind.IfStatement))
{
return;
}
SyntaxTriviaList trailingTrivia = elseClause.ElseKeyword.TrailingTrivia;
if (!SyntaxTriviaAnalysis.IsOptionalWhitespaceThenEndOfLineTrivia(trailingTrivia))
{
return;
}
if (!statement.GetLeadingTrivia().IsEmptyOrWhitespace())
{
return;
}
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticDescriptors.RemoveNewLineBetweenIfKeywordAndElseKeyword,
Location.Create(elseClause.SyntaxTree, new TextSpan(trailingTrivia.Last().SpanStart, 0)));
}
private static bool TryGetExpression(StatementSyntax firstStatement, LanguageVersion languageVersion, [NotNullWhen(true)] out ExpressionSyntax?expression, out SyntaxToken semicolonToken)
{
if (firstStatement is ExpressionStatementSyntax exprStatement)
{
expression = exprStatement.Expression;
semicolonToken = exprStatement.SemicolonToken;
return(true);
}
else if (firstStatement is ReturnStatementSyntax returnStatement)
{
if (returnStatement.Expression != null)
{
// If there are any comments or directives on the return keyword, move them to
// the expression.
expression = firstStatement.GetLeadingTrivia().Any(t => t.IsDirective || t.IsSingleOrMultiLineComment())
? returnStatement.Expression.WithLeadingTrivia(returnStatement.GetLeadingTrivia())
: returnStatement.Expression;
semicolonToken = returnStatement.SemicolonToken;
return(true);
}
}
else if (firstStatement is ThrowStatementSyntax throwStatement)
{
if (languageVersion >= LanguageVersion.CSharp7 && throwStatement.Expression != null)
{
expression = SyntaxFactory.ThrowExpression(throwStatement.ThrowKeyword, throwStatement.Expression);
semicolonToken = throwStatement.SemicolonToken;
return(true);
}
}
expression = null;
semicolonToken = default;
return(false);
}
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));
}
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));
}
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 async Task <Document> RefactorAsync(
Document document,
StatementSyntax statement,
CancellationToken cancellationToken)
{
StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(statement);
var methodDeclaration = (MethodDeclarationSyntax)statementsInfo.Parent.Parent;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
string name = methodDeclaration.Identifier.ValueText;
if (!name.EndsWith("Iterator", StringComparison.Ordinal))
{
name += "Iterator";
}
name = NameGenerator.Default.EnsureUniqueLocalName(name, semanticModel, statement.SpanStart, cancellationToken: cancellationToken);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(statement);
List <StatementSyntax> localFunctionStatements = statements.Skip(index).ToList();
int lastIndex = localFunctionStatements.Count - 1;
localFunctionStatements[lastIndex] = localFunctionStatements[lastIndex].WithoutTrailingTrivia();
LocalFunctionStatementSyntax localFunction = LocalFunctionStatement(
default(SyntaxTokenList),
methodDeclaration.ReturnType.WithoutTrivia(),
Identifier(name).WithRenameAnnotation(),
ParameterList(),
Block(localFunctionStatements).WithTrailingTrivia(statements.Last().GetTrailingTrivia()));
localFunction = localFunction.WithFormatterAnnotation();
ReturnStatementSyntax returnStatement = ReturnStatement(
Token(SyntaxKind.ReturnKeyword).WithLeadingTrivia(statement.GetLeadingTrivia()),
InvocationExpression(IdentifierName(name)),
SemicolonToken());
SyntaxList <StatementSyntax> newStatements = statements.ReplaceRange(
index,
statements.Count - index,
new StatementSyntax[] { returnStatement, localFunction });
return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false));
}
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);
}
public static StatementSyntax InsertLeadingEndOfLine(this StatementSyntax statement)
{
var leadingTrivia = statement.GetLeadingTrivia();
if (leadingTrivia.Count > 0 && leadingTrivia[0].IsKind(SyntaxKind.EndOfLineTrivia))
{
return(statement);
}
else
{
leadingTrivia = leadingTrivia.Insert(0, SyntaxFactory.EndOfLine(Environment.NewLine));
return(statement.WithLeadingTrivia(leadingTrivia));
}
}
private async Task <Document> AddNewLineBefore(
Document document,
StatementSyntax statement,
CancellationToken cancellationToken)
{
var leadingTriviaWithEOL = statement.GetLeadingTrivia().Insert(0, SyntaxFactory.EndOfLine(Environment.NewLine));
var newStatement = statement.WithLeadingTrivia(leadingTriviaWithEOL);
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
root = root.ReplaceNode(statement, newStatement);
return(document.WithSyntaxRoot(root));
}
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 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 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));
}
StatementSyntax ApplyNodeChange(StatementSyntax statementNode)
{
var isCleanupDone = false;
var leadingTriviaList = statementNode.GetLeadingTrivia();
if (statementNode.IsKind(SyntaxKind.EmptyStatement)) // remove unused semicolons
{
return(null);
}
if (_lastTokenIsACloseBrace)
{
if (CheckOption((int)CleanupTypes.Adding_Blank_After_Block_Close_Bracket))
{
if (leadingTriviaList.Count(x => x.IsKind(SyntaxKind.EndOfLineTrivia)) < 2)
{
leadingTriviaList = CleanUpListWithExactNumberOfWhiteSpaces(leadingTriviaList, 1, null);
isCleanupDone = true;
}
}
else if (CheckOption((int)CleanupTypes.RemoveDuplicateBetweenMethodsStatements))
{
leadingTriviaList = CleanUpListWithDefaultWhiteSpaces(leadingTriviaList, null);
isCleanupDone = true;
}
}
else if (CheckOption((int)CleanupTypes.RemoveDuplicateBetweenMethodsStatements))
{
leadingTriviaList = CleanUpListWithDefaultWhiteSpaces(leadingTriviaList, null);
isCleanupDone = true;
}
if (!isCleanupDone)
{
leadingTriviaList = ProcessSpecialTrivias(leadingTriviaList, false);
}
statementNode = statementNode.WithLeadingTrivia(leadingTriviaList);
// _LastMember = null;
return(statementNode);
}
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 IEnumerable <StatementSyntax> GetNewNodes(StatementSyntax statement)
{
List <SyntaxTrivia> list;
if (statement.IsParentKind(SyntaxKind.ElseClause))
{
list = new List <SyntaxTrivia>()
{
CSharpFactory.NewLine()
};
}
else
{
list = statement.Parent.GetLeadingTrivia()
.Reverse()
.SkipWhile(f => f.IsWhitespaceTrivia())
.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));
}
}
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,
StatementSyntax statement,
CancellationToken cancellationToken)
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken);
StatementSyntax newStatement = statement
.WithLeadingTrivia(statement.GetLeadingTrivia().Insert(0, SyntaxHelper.NewLine))
.WithAdditionalAnnotations(Formatter.Annotation);
if (statement.Parent.IsKind(SyntaxKind.Block))
{
var block = (BlockSyntax)statement.Parent;
if (block.IsSingleline(includeExteriorTrivia: false))
{
SyntaxTriviaList triviaList = block.CloseBraceToken.LeadingTrivia
.Add(SyntaxHelper.NewLine);
BlockSyntax newBlock = block
.WithCloseBraceToken(block.CloseBraceToken.WithLeadingTrivia(triviaList))
.WithStatements(block.Statements.Replace(statement, newStatement))
.WithAdditionalAnnotations(Formatter.Annotation);
root = root.ReplaceNode(block, newBlock);
}
else
{
root = root.ReplaceNode(statement, newStatement);
}
}
else
{
root = root.ReplaceNode(statement, newStatement);
}
return(document.WithSyntaxRoot(root));
}
StatementSyntax ApplyNodeChange(StatementSyntax statementNode)
{
var triviList = statementNode.GetLeadingTrivia();
var zeroCondition = _lastTokenIsAOpenBrace || _lastToken == default(SyntaxToken);
if (zeroCondition)
{
triviList = CleanUpListWithExactNumberOfWhitespaces(triviList, 0);
}
else if (_lastTokenIsACloseBrace)
{
triviList = CleanUpListWithExactNumberOfWhitespaces(triviList, 1, itsForCloseBrace: false);
}
else
{
triviList = CleanUpListWithDefaultWhitespaces(triviList);
}
statementNode = statementNode.WithLeadingTrivia(triviList);
return(statementNode);
}
public static StatementSyntax Trivia(this StatementSyntax node, StatementSyntax that)
{
return node.WithLeadingTrivia(that.GetLeadingTrivia()).WithTrailingTrivia(that.GetTrailingTrivia());
}
public static void AnalyzerSwitchSection(SyntaxNodeAnalysisContext context)
{
var switchSection = (SwitchSectionSyntax)context.Node;
if (!(switchSection.Statements.SingleOrDefault(shouldThrow: false) is BlockSyntax block))
{
return;
}
SyntaxList <StatementSyntax> statements = block.Statements;
StatementSyntax firstStatement = statements.FirstOrDefault();
if (firstStatement == null)
{
return;
}
SyntaxToken openBrace = block.OpenBraceToken;
if (!AnalyzeTrivia(openBrace.LeadingTrivia))
{
return;
}
if (!AnalyzeTrivia(openBrace.TrailingTrivia))
{
return;
}
if (!AnalyzeTrivia(firstStatement.GetLeadingTrivia()))
{
return;
}
StatementSyntax lastStatement = statements.Last();
if (!AnalyzeTrivia(lastStatement.GetTrailingTrivia()))
{
return;
}
SyntaxToken closeBrace = block.CloseBraceToken;
if (!AnalyzeTrivia(closeBrace.LeadingTrivia))
{
return;
}
if (!AnalyzeTrivia(closeBrace.TrailingTrivia))
{
return;
}
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveUnnecessaryBraces, openBrace);
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.RemoveUnnecessaryBracesFadeOut, closeBrace);
bool AnalyzeTrivia(SyntaxTriviaList trivia)
{
return(trivia.All(f => f.IsKind(SyntaxKind.WhitespaceTrivia, SyntaxKind.EndOfLineTrivia, SyntaxKind.SingleLineCommentTrivia)));
}
}
private static UsingStatementSyntax CreateUsingStatement(StatementSyntax statement, BlockSyntax block)
{
return SyntaxFactory.UsingStatement(block)
.WithLeadingTrivia(statement.GetLeadingTrivia())
.WithTrailingTrivia(statement.GetTrailingTrivia())
.WithAdditionalAnnotations(Formatter.Annotation);
}
public static StatementSyntax WithoutLeadingBlankLinesInTrivia(this StatementSyntax statement) => statement.WithLeadingTrivia(statement.GetLeadingTrivia().WithoutLeadingBlankLines());
private static async Task <Document> RefactorAsync(
Document document,
StringConcatenationExpression concatenation,
StatementSyntax statement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
string name = NameGenerator.Default.EnsureUniqueLocalName(DefaultNames.StringBuilderVariable, semanticModel, statement.SpanStart, cancellationToken: cancellationToken);
IdentifierNameSyntax stringBuilderName = IdentifierName(name);
TypeSyntax type = semanticModel.GetTypeByMetadataName(MetadataNames.System_Text_StringBuilder).ToMinimalTypeSyntax(semanticModel, statement.SpanStart);
var statements = new List <StatementSyntax>()
{
LocalDeclarationStatement(VarType(), Identifier(name).WithRenameAnnotation(), ObjectCreationExpression(type, ArgumentList())).WithLeadingTrivia(statement.GetLeadingTrivia())
};
ImmutableArray <ExpressionSyntax> expressions = concatenation.Expressions;
ExpressionSyntax newInvocation = null;
for (int i = 0; i < expressions.Length; i++)
{
if (expressions[i].IsKind(SyntaxKind.InterpolatedStringExpression))
{
var interpolatedString = (InterpolatedStringExpressionSyntax)expressions[i];
bool isVerbatim = interpolatedString.IsVerbatim();
SyntaxList <InterpolatedStringContentSyntax> contents = interpolatedString.Contents;
for (int j = 0; j < contents.Count; j++)
{
InterpolatedStringContentConversion conversion = InterpolatedStringContentConversion.Create(contents[j], isVerbatim);
newInvocation = SimpleMemberInvocationExpression(
newInvocation ?? stringBuilderName,
IdentifierName(conversion.Name),
ArgumentList(conversion.Arguments));
}
}
else
{
newInvocation = SimpleMemberInvocationExpression(
newInvocation ?? stringBuilderName,
IdentifierName("Append"),
Argument(expressions[i].WithoutTrivia()));
}
}
statements.Add(ExpressionStatement(newInvocation));
statements.Add(statement
.ReplaceNode(concatenation.OriginalExpression, SimpleMemberInvocationExpression(stringBuilderName, IdentifierName("ToString")))
.WithTrailingTrivia(statement.GetTrailingTrivia())
.WithoutLeadingTrivia());
if (EmbeddedStatementHelper.IsEmbeddedStatement(statement))
{
BlockSyntax block = Block(statements).WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(statement, block, cancellationToken).ConfigureAwait(false));
}
else
{
for (int i = 0; i < statements.Count; i++)
{
statements[i] = statements[i].WithFormatterAnnotation();
}
return(await document.ReplaceNodeAsync(statement, statements, cancellationToken).ConfigureAwait(false));
}
}
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;
}
/// <summary> /// Applies whitespace trivia and new line trivia from another statement syntax to this one. /// </summary> /// <param name="statement">The StatementSyntax to update.</param> /// <param name="otherStatement">The StatementSyntax to copy trivia from.</param> /// <returns>The original statement syntax updated with the other statement syntax's whitespace and new line trivia.</returns> public static StatementSyntax WithWhitespaceTriviaFrom(this StatementSyntax statement, StatementSyntax otherStatement) => statement .WithLeadingTrivia(otherStatement?.GetLeadingTrivia().Where(t => t.IsKind(SyntaxKind.EndOfLineTrivia) || t.IsKind(SyntaxKind.WhitespaceTrivia)) ?? SyntaxTriviaList.Empty) .WithTrailingTrivia(otherStatement?.GetTrailingTrivia().Where(t => t.IsKind(SyntaxKind.EndOfLineTrivia) || t.IsKind(SyntaxKind.WhitespaceTrivia)) ?? SyntaxTriviaList.Empty);
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;
}
private static async Task <StatementsInfo> RefactorAsync(
Document document,
StatementsInfo statementsInfo,
StatementSyntax statement,
StatementSyntax newStatement,
int index,
int count,
bool removeReturnStatement,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
ReturnStatementSyntax returnStatement = FindReturnStatementBelow(statementsInfo.Statements, index);
ExpressionSyntax expression = returnStatement.Expression;
ExpressionSyntax newExpression = null;
ISymbol symbol = semanticModel.GetSymbol(expression, cancellationToken);
if (symbol.IsLocal() &&
index > 0)
{
LocalDeclarationStatementSyntax localDeclarationStatement = FindLocalDeclarationStatementAbove(statementsInfo.Statements, index);
if (localDeclarationStatement?.ContainsDiagnostics == false &&
!localDeclarationStatement.SpanOrTrailingTriviaContainsDirectives() &&
!statement.GetLeadingTrivia().Any(f => f.IsDirective))
{
SeparatedSyntaxList <VariableDeclaratorSyntax> declarators = localDeclarationStatement.Declaration.Variables;
VariableDeclaratorSyntax declarator = FindVariableDeclarator(semanticModel, symbol, declarators, cancellationToken);
if (declarator != null)
{
ExpressionSyntax value = declarator.Initializer?.Value;
if (removeReturnStatement || value != null)
{
IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync(symbol, document.Solution(), cancellationToken).ConfigureAwait(false);
if (referencedSymbols.First().Locations.Count() == count + 1)
{
newExpression = value;
if (declarators.Count == 1)
{
statementsInfo = statementsInfo.RemoveNode(localDeclarationStatement, RemoveHelper.GetRemoveOptions(localDeclarationStatement));
index--;
}
else
{
statementsInfo = statementsInfo.ReplaceNode(localDeclarationStatement, localDeclarationStatement.RemoveNode(declarator, RemoveHelper.GetRemoveOptions(declarator)));
}
returnStatement = FindReturnStatementBelow(statementsInfo.Statements, index);
}
}
}
}
}
if (removeReturnStatement)
{
statementsInfo = statementsInfo.RemoveNode(returnStatement, RemoveHelper.GetRemoveOptions(returnStatement));
}
else if (newExpression != null)
{
statementsInfo = statementsInfo.ReplaceNode(returnStatement, returnStatement.WithExpression(newExpression.WithTriviaFrom(expression)));
}
return(statementsInfo.ReplaceNode(statementsInfo.Statements[index], newStatement));
}