public static async Task <Document> RefactorAsync(
Document document,
StatementContainer container,
IfStatementSyntax ifStatement,
ReturnStatementSyntax returnStatement,
CancellationToken cancellationToken)
{
ExpressionSyntax expression = ReplaceIfWithStatementRefactoring.GetExpression(
ifStatement.Condition,
ReplaceIfWithStatementRefactoring.GetReturnExpression(ifStatement),
returnStatement.Expression);
ReturnStatementSyntax newReturnStatement = ReturnStatement(expression);
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(ifStatement);
newReturnStatement = newReturnStatement
.WithLeadingTrivia(ifStatement.GetLeadingTrivia())
.WithTrailingTrivia(returnStatement.GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statements
.RemoveAt(index)
.ReplaceAt(index, newReturnStatement);
return(await document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false));
}
private static async Task <Document> RefactorAsync(
Document document,
StatementContainer container,
IfStatementSyntax ifStatement,
ReturnStatementSyntax returnStatement,
ExpressionSyntax whenTrue,
ExpressionSyntax whenFalse,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(ifStatement);
ConditionalExpressionSyntax conditionalExpression = ReplaceIfWithStatementRefactoring.CreateConditionalExpression(ifStatement.Condition, whenTrue, whenFalse);
ReturnStatementSyntax newReturnStatement = ReturnStatement(conditionalExpression)
.WithLeadingTrivia(ifStatement.GetLeadingTrivia())
.WithTrailingTrivia(returnStatement.GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statements
.Remove(returnStatement)
.ReplaceAt(index, newReturnStatement);
return(await document.ReplaceNodeAsync(container.Node, container.NodeWithStatements(newStatements), cancellationToken).ConfigureAwait(false));
}
private TStatement GetStatement(ElseClauseSyntax elseClause)
{
StatementSyntax statement = ReplaceIfWithStatementRefactoring.GetStatement(elseClause);
if (statement?.IsKind(StatementKind) == true)
{
return((TStatement)statement);
}
return(null);
}
private TStatement GetStatement(IfStatementSyntax ifStatement)
{
StatementSyntax statement = ReplaceIfWithStatementRefactoring.GetStatement(ifStatement);
if (statement?.IsKind(StatementKind) == true)
{
return((TStatement)statement);
}
return(null);
}
public static void ComputeRefactoring(RefactoringContext context, SelectedStatementCollection selectedStatements)
{
if (selectedStatements.Count == 2)
{
StatementSyntax[] statements = selectedStatements.ToArray();
if (statements[0].IsKind(SyntaxKind.IfStatement) &&
statements[1].IsKind(SyntaxKind.ReturnStatement))
{
var ifStatement = (IfStatementSyntax)statements[0];
if (!IfElseChain.IsPartOfChain(ifStatement))
{
ExpressionSyntax returnExpression = ReplaceIfWithStatementRefactoring.GetReturnExpression(ifStatement);
if (returnExpression != null)
{
var returnStatement = (ReturnStatementSyntax)statements[1];
ExpressionSyntax returnExpression2 = returnStatement.Expression;
if (returnExpression2 != null)
{
const string title = "Replace if-return with return";
if (returnExpression.IsBooleanLiteralExpression() ||
returnExpression2.IsBooleanLiteralExpression())
{
context.RegisterRefactoring(
title,
cancellationToken => RefactorAsync(context.Document, selectedStatements.Container, ifStatement, returnStatement, cancellationToken));
}
else
{
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(RefactorAsync(
context.Document,
selectedStatements.Container,
ifStatement,
returnStatement,
returnExpression,
returnExpression2,
cancellationToken));
});
}
}
}
}
}
}
}
private async Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
ExpressionSyntax expression1,
ExpressionSyntax expression2,
CancellationToken cancellationToken)
{
ExpressionSyntax expression = ReplaceIfWithStatementRefactoring.GetExpression(ifStatement.Condition, expression1, expression2);
TStatement newNode = CreateStatement(expression)
.WithTriviaFrom(ifStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken).ConfigureAwait(false));
}
private async Task <Document> RefactorWithConditionalExpressionAsync(
Document document,
IfStatementSyntax ifStatement,
ExpressionSyntax whenTrue,
ExpressionSyntax whenFalse,
CancellationToken cancellationToken)
{
ConditionalExpressionSyntax conditionalExpression = ReplaceIfWithStatementRefactoring.CreateConditionalExpression(ifStatement.Condition, whenTrue, whenFalse);
TStatement newNode = CreateStatement(conditionalExpression);
newNode = newNode
.WithTriviaFrom(ifStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken).ConfigureAwait(false));
}
public static void ComputeRefactoring(RefactoringContext context, IfStatementSyntax ifStatement)
{
if (IfElseChain.IsTopmostIf(ifStatement))
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause != null)
{
StatementSyntax statement1 = ReplaceIfWithStatementRefactoring.GetStatement(ifStatement);
if (statement1?.IsKind(SyntaxKind.ExpressionStatement) == true)
{
StatementSyntax statement2 = ReplaceIfWithStatementRefactoring.GetStatement(elseClause);
if (statement2?.IsKind(SyntaxKind.ExpressionStatement) == true)
{
var expressionStatement1 = (ExpressionStatementSyntax)statement1;
var expressionStatement2 = (ExpressionStatementSyntax)statement2;
ExpressionSyntax expression1 = expressionStatement1.Expression;
if (expression1?.IsKind(SyntaxKind.SimpleAssignmentExpression) == true)
{
ExpressionSyntax expression2 = expressionStatement2.Expression;
if (expression2?.IsKind(SyntaxKind.SimpleAssignmentExpression) == true)
{
var assignment1 = (AssignmentExpressionSyntax)expression1;
var assignment2 = (AssignmentExpressionSyntax)expression2;
ExpressionSyntax left1 = assignment1.Left;
ExpressionSyntax right1 = assignment1.Right;
if (left1?.IsMissing == false &&
right1?.IsMissing == false)
{
ExpressionSyntax left2 = assignment2.Left;
ExpressionSyntax right2 = assignment2.Right;
if (left2?.IsMissing == false &&
right2?.IsMissing == false &&
left1.IsEquivalentTo(left2, topLevel: false))
{
context.RegisterRefactoring(
"Replace if-else with assignment",
cancellationToken =>
{
return(RefactorAsync(
context.Document,
ifStatement,
left1,
right1,
right2,
cancellationToken));
});
}
}
}
}
}
}
}
}
}
