public static async Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
IfStatementSyntax nestedIf = GetNestedIfStatement(ifStatement);
BinaryExpressionSyntax newCondition = CSharpFactory.LogicalAndExpression(
ifStatement.Condition,
nestedIf.Condition,
addParenthesesIfNecessary: true);
IfStatementSyntax newNode = GetNewIfStatement(ifStatement, nestedIf)
.WithCondition(newCondition)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken).ConfigureAwait(false));
}
public static Task <Document> RefactorAsync(
Document document,
InvocationExpressionSyntax invocationExpression,
CancellationToken cancellationToken)
{
MemberInvocationExpressionWithSingleParameter invocation = MemberInvocationExpressionWithSingleParameter.Create(invocationExpression);
MemberInvocationExpressionWithSingleParameter invocation2 = MemberInvocationExpressionWithSingleParameter.Create((InvocationExpressionSyntax)invocation.Expression);
LambdaExpressionWithSingleParameter lambda = LambdaExpressionWithSingleParameter.Create((LambdaExpressionSyntax)invocation.Argument.Expression);
LambdaExpressionWithSingleParameter lambda2 = LambdaExpressionWithSingleParameter.Create((LambdaExpressionSyntax)invocation2.Argument.Expression);
BinaryExpressionSyntax logicalAnd = CSharpFactory.LogicalAndExpression(
((ExpressionSyntax)lambda2.Body).Parenthesize(moveTrivia: true).WithSimplifierAnnotation(),
((ExpressionSyntax)lambda.Body).Parenthesize(moveTrivia: true).WithSimplifierAnnotation());
InvocationExpressionSyntax newNode = invocation2.InvocationExpression
.ReplaceNode(invocation2.Name, invocation.Name.WithTriviaFrom(invocation2.Name))
.WithArgumentList(invocation2.ArgumentList.ReplaceNode((ExpressionSyntax)lambda2.Body, logicalAnd));
return(document.ReplaceNodeAsync(invocationExpression, newNode, cancellationToken));
}
public static Task <Document> RefactorAsync(
Document document,
InvocationExpressionSyntax invocationExpression,
CancellationToken cancellationToken)
{
MemberInvocationExpressionInfo invocationInfo = SyntaxInfo.MemberInvocationExpressionInfo(invocationExpression);
MemberInvocationExpressionInfo invocationInfo2 = SyntaxInfo.MemberInvocationExpressionInfo(invocationInfo.Expression);
SingleParameterLambdaExpressionInfo lambda = SyntaxInfo.SingleParameterLambdaExpressionInfo((LambdaExpressionSyntax)invocationInfo.Arguments.First().Expression);
SingleParameterLambdaExpressionInfo lambda2 = SyntaxInfo.SingleParameterLambdaExpressionInfo((LambdaExpressionSyntax)invocationInfo2.Arguments.First().Expression);
BinaryExpressionSyntax logicalAnd = CSharpFactory.LogicalAndExpression(
((ExpressionSyntax)lambda2.Body).Parenthesize(),
((ExpressionSyntax)lambda.Body).Parenthesize());
InvocationExpressionSyntax newNode = invocationInfo2.InvocationExpression
.ReplaceNode(invocationInfo2.Name, invocationInfo.Name.WithTriviaFrom(invocationInfo2.Name))
.WithArgumentList(invocationInfo2.ArgumentList.ReplaceNode((ExpressionSyntax)lambda2.Body, logicalAnd));
return(document.ReplaceNodeAsync(invocationExpression, newNode, cancellationToken));
}
private static async Task <Document> MergeIfStatementWithNestedIfStatementAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
IfStatementSyntax nestedIf = GetNestedIfStatement(ifStatement);
BinaryExpressionSyntax newCondition = CSharpFactory.LogicalAndExpression(
ifStatement.Condition,
nestedIf.Condition,
addParenthesesIfNecessary: true);
IfStatementSyntax newNode = GetNewIfStatement(ifStatement, nestedIf)
.WithCondition(newCondition)
.WithFormatterAnnotation();
SyntaxNode newRoot = oldRoot.ReplaceNode(ifStatement, newNode);
return(document.WithSyntaxRoot(newRoot));
}
public static Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
IfStatementSyntax nestedIf = GetNestedIfStatement(ifStatement);
ExpressionSyntax left = ifStatement.Condition.Parenthesize();
ExpressionSyntax right = nestedIf.Condition;
if (!right.IsKind(SyntaxKind.LogicalAndExpression))
{
right = right.Parenthesize();
}
BinaryExpressionSyntax newCondition = CSharpFactory.LogicalAndExpression(left, right);
IfStatementSyntax newNode = GetNewIfStatement(ifStatement, nestedIf)
.WithCondition(newCondition)
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken));
}
private static ExpressionSyntax LogicalAndExpression(ExpressionSyntax left, ExpressionSyntax right)
{
return(CSharpFactory.LogicalAndExpression(
left.Parenthesize(),
right.Parenthesize()));
}
private static ExpressionSyntax GetBooleanExpression(
ExpressionSyntax condition,
ExpressionSyntax expression1,
ExpressionSyntax expression2,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
switch (expression1.Kind())
{
case SyntaxKind.TrueLiteralExpression:
{
switch (expression2.Kind())
{
case SyntaxKind.TrueLiteralExpression:
return(expression2);
case SyntaxKind.FalseLiteralExpression:
return(condition);
default:
return(LogicalOrExpression(condition, expression2));
}
}
case SyntaxKind.FalseLiteralExpression:
{
switch (expression2.Kind())
{
case SyntaxKind.TrueLiteralExpression:
return(Negator.LogicallyNegate(condition, semanticModel, cancellationToken));
case SyntaxKind.FalseLiteralExpression:
return(expression2);
default:
return(LogicalAndExpression(Negator.LogicallyNegate(condition, semanticModel, cancellationToken), expression2));
}
}
default:
{
switch (expression2.Kind())
{
case SyntaxKind.TrueLiteralExpression:
return(LogicalOrExpression(Negator.LogicallyNegate(condition, semanticModel, cancellationToken), expression1));
case SyntaxKind.FalseLiteralExpression:
return(LogicalAndExpression(condition, expression1));
default:
throw new InvalidOperationException();
}
}
}
BinaryExpressionSyntax LogicalAndExpression(ExpressionSyntax left, ExpressionSyntax right)
{
return(CSharpFactory.LogicalAndExpression(
left.Parenthesize(),
right.Parenthesize()));
}
BinaryExpressionSyntax LogicalOrExpression(ExpressionSyntax left, ExpressionSyntax right)
{
return(CSharpFactory.LogicalOrExpression(
left.Parenthesize(),
right.Parenthesize()));
}
}
private static ExpressionSyntax LogicalAndExpression(ExpressionSyntax left, ExpressionSyntax right)
{
return(CSharpFactory.LogicalAndExpression(
left.Parenthesize(moveTrivia: true).WithSimplifierAnnotation(),
right.Parenthesize(moveTrivia: true).WithSimplifierAnnotation()));
}