protected TStatement AddNestedIf(
TStatement statement,
BinaryExpressionSpan binaryExpressionSpan)
{
ExpressionSyntax expression = ParseExpression(binaryExpressionSpan.ToString());
return(AddNestedIf(statement, expression));
}
internal static void ComputeRefactoring(RefactoringContext context, BinaryExpressionSpan binaryExpressionSpan)
{
BinaryExpressionSyntax binaryExpression = binaryExpressionSpan.BinaryExpression;
SyntaxKind kind = binaryExpression.Kind();
if (kind == SyntaxKind.LogicalAndExpression ||
kind == SyntaxKind.LogicalOrExpression)
{
BinaryExpressionSyntax condition = GetCondition(binaryExpression);
if (condition != null)
{
SyntaxNode parent = condition.Parent;
switch (parent?.Kind())
{
case SyntaxKind.IfStatement:
{
if (kind == SyntaxKind.LogicalAndExpression)
{
var refactoring = new ExtractConditionFromIfToNestedIfRefactoring();
context.RegisterRefactoring(
refactoring.Title,
cancellationToken => refactoring.RefactorAsync(context.Document, (IfStatementSyntax)parent, condition, binaryExpressionSpan, cancellationToken));
}
else if (kind == SyntaxKind.LogicalOrExpression)
{
IStatementContainer container = GetStatementContainer((StatementSyntax)parent);
if (container != null)
{
var refactoring = new ExtractConditionFromIfToIfRefactoring();
context.RegisterRefactoring(
refactoring.Title,
cancellationToken => refactoring.RefactorAsync(context.Document, container, condition, binaryExpressionSpan, cancellationToken));
}
}
break;
}
case SyntaxKind.WhileStatement:
{
if (kind == SyntaxKind.LogicalAndExpression)
{
var refactoring = new ExtractConditionFromWhileToNestedIfRefactoring();
context.RegisterRefactoring(
refactoring.Title,
cancellationToken => refactoring.RefactorAsync(context.Document, (WhileStatementSyntax)parent, condition, binaryExpressionSpan, cancellationToken));
}
break;
}
}
}
}
}
protected TStatement RemoveExpressionsFromCondition(
TStatement statement,
BinaryExpressionSyntax condition,
BinaryExpressionSpan binaryExpressionSpan)
{
var binaryExpression = (BinaryExpressionSyntax)binaryExpressionSpan.SelectedExpressions[0].Parent;
return(statement.ReplaceNode(
condition,
binaryExpression.Left.TrimTrailingTrivia()));
}
public Task <Document> RefactorAsync(
Document document,
WhileStatementSyntax whileStatement,
BinaryExpressionSyntax condition,
BinaryExpressionSpan binaryExpressionSpan,
CancellationToken cancellationToken = default(CancellationToken))
{
WhileStatementSyntax newNode = RemoveExpressionsFromCondition(whileStatement, condition, binaryExpressionSpan);
newNode = AddNestedIf(newNode, binaryExpressionSpan)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(whileStatement, newNode, cancellationToken));
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, BinaryExpressionSpan binaryExpressionSpan)
{
if (binaryExpressionSpan.BinaryExpression.IsKind(SyntaxKind.AddExpression))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
StringExpressionChain chain = StringExpressionChain.TryCreate(binaryExpressionSpan, semanticModel, context.CancellationToken);
if (chain != null)
{
ComputeRefactoring(context, chain);
}
}
}
public Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
BinaryExpressionSyntax condition,
BinaryExpressionSpan binaryExpressionSpan,
CancellationToken cancellationToken)
{
IfStatementSyntax newNode = RemoveExpressionsFromCondition(ifStatement, condition, binaryExpressionSpan);
ExpressionSyntax expression = SyntaxFactory.ParseExpression(binaryExpressionSpan.ToString());
newNode = AddNestedIf(newNode, expression)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken));
}
public Task <Document> RefactorAsync(
Document document,
IStatementContainer container,
BinaryExpressionSyntax condition,
BinaryExpressionSpan binaryExpressionSpan,
CancellationToken cancellationToken)
{
var ifStatement = (IfStatementSyntax)condition.Parent;
IfStatementSyntax newIfStatement = RemoveExpressionsFromCondition(ifStatement, condition, binaryExpressionSpan)
.WithFormatterAnnotation();
ExpressionSyntax expression = SyntaxFactory.ParseExpression(binaryExpressionSpan.ToString());
SyntaxNode newNode = AddNextIf(container, ifStatement, newIfStatement, expression);
return(document.ReplaceNodeAsync(container.Node, newNode, cancellationToken));
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, BinaryExpressionSyntax binaryExpression)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.NegateOperator))
{
SyntaxToken operatorToken = binaryExpression.OperatorToken;
if (operatorToken.Span.Contains(context.Span) &&
NegateOperatorRefactoring.CanBeNegated(operatorToken))
{
context.RegisterRefactoring(
"Negate operator",
cancellationToken => NegateOperatorRefactoring.RefactorAsync(context.Document, operatorToken, cancellationToken));
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatBinaryExpression))
{
FormatBinaryExpressionRefactoring.ComputeRefactorings(context, binaryExpression);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.NegateBinaryExpression))
{
NegateBinaryExpressionRefactoring.ComputeRefactoring(context, binaryExpression);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExpandCoalesceExpression) &&
binaryExpression.OperatorToken.Span.Contains(context.Span))
{
ExpandCoalesceExpressionRefactoring.ComputeRefactoring(context, binaryExpression);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeStringExpressions) &&
context.Span.IsBetweenSpans(binaryExpression))
{
await MergeStringExpressionsRefactoring.ComputeRefactoringAsync(context, binaryExpression).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapExpressionsInBinaryExpression) &&
context.Span.IsBetweenSpans(binaryExpression))
{
SwapExpressionsInBinaryExpressionRefactoring.ComputeRefactoring(context, binaryExpression);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceAsWithCast) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(binaryExpression))
{
ReplaceAsWithCastRefactoring.ComputeRefactoring(context, binaryExpression);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.NegateIsExpression))
{
NegateIsExpressionRefactoring.ComputeRefactoring(context, binaryExpression);
}
if (context.Span.IsContainedInSpanOrBetweenSpans(binaryExpression.OperatorToken))
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceEqualsExpressionWithStringEquals))
{
await ReplaceEqualsExpressionWithStringEqualsRefactoring.ComputeRefactoringAsync(context, binaryExpression).ConfigureAwait(false);
}
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ReplaceEqualsExpressionWithStringIsNullOrEmpty,
RefactoringIdentifiers.ReplaceEqualsExpressionWithStringIsNullOrWhiteSpace))
{
await ReplaceEqualsExpressionRefactoring.ComputeRefactoringsAsync(context, binaryExpression).ConfigureAwait(false);
}
}
if (!context.Span.IsBetweenSpans(binaryExpression) &&
context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.ExtractExpressionFromCondition,
RefactoringIdentifiers.MergeStringExpressions))
{
BinaryExpressionSpan binaryExpressionSpan = BinaryExpressionSpan.Create(binaryExpression, context.Span);
if (binaryExpressionSpan.SelectedExpressions.Length > 1)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ExtractExpressionFromCondition))
{
ExtractConditionRefactoring.ComputeRefactoring(context, binaryExpressionSpan);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeStringExpressions))
{
await MergeStringExpressionsRefactoring.ComputeRefactoringAsync(context, binaryExpressionSpan).ConfigureAwait(false);
}
}
}
}
