public static async Task <Document> RefactorAsync(
Document document,
ConditionalExpressionSyntax conditionalExpression,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax condition = conditionalExpression.Condition;
ExpressionSyntax newNode = (conditionalExpression.WhenTrue.WalkDownParentheses().IsKind(SyntaxKind.TrueLiteralExpression))
? condition
: LogicalNegationHelper.LogicallyNegate(condition, semanticModel, cancellationToken);
SyntaxTriviaList trailingTrivia = conditionalExpression
.DescendantTrivia(TextSpan.FromBounds(condition.Span.End, conditionalExpression.Span.End))
.ToSyntaxTriviaList()
.EmptyIfWhitespace()
.AddRange(conditionalExpression.GetTrailingTrivia());
newNode = newNode
.WithLeadingTrivia(conditionalExpression.GetLeadingTrivia())
.WithTrailingTrivia(trailingTrivia);
return(await document.ReplaceNodeAsync(conditionalExpression, newNode, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
ElseClauseSyntax elseClause = ifStatement.Else;
StatementSyntax whenTrue = ifStatement.Statement;
StatementSyntax whenFalse = elseClause.Statement;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ElseClauseSyntax newElseClause = null;
if ((whenFalse as BlockSyntax)?.Statements.Any() != false)
{
newElseClause = elseClause.WithStatement(whenTrue.WithTriviaFrom(whenFalse));
}
IfStatementSyntax newIfStatement = ifStatement
.WithCondition(LogicalNegationHelper.LogicallyNegate(ifStatement.Condition, semanticModel, cancellationToken))
.WithStatement(whenFalse.WithTriviaFrom(whenTrue))
.WithElse(newElseClause)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false));
}
public 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(LogicalNegationHelper.LogicallyNegate(condition, semanticModel, cancellationToken));
case SyntaxKind.FalseLiteralExpression:
return(expression2);
default:
return(LogicalAndExpression(LogicalNegationHelper.LogicallyNegate(condition, semanticModel, cancellationToken), expression2));
}
}
default:
{
switch (expression2.Kind())
{
case SyntaxKind.TrueLiteralExpression:
return(LogicalOrExpression(LogicalNegationHelper.LogicallyNegate(condition, semanticModel, cancellationToken), expression1));
case SyntaxKind.FalseLiteralExpression:
return(LogicalAndExpression(condition, expression1));
default:
throw new InvalidOperationException();
}
}
}
}
private static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax newNode = LogicalNegationHelper.LogicallyNegate(expression, semanticModel, cancellationToken);
return(await document.ReplaceNodeAsync(expression, newNode, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
BinaryExpressionSyntax binaryExpression,
CancellationToken cancellationToken = default(CancellationToken))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ExpressionSyntax newNode = LogicalNegationHelper.LogicallyNegate(binaryExpression, semanticModel, cancellationToken);
newNode = newNode.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(binaryExpression, newNode, cancellationToken).ConfigureAwait(false));
}
public override async Task <Document> RefactorAsync(Document document, CancellationToken cancellationToken = default(CancellationToken))
{
ExpressionSyntax right = Right.WithoutTrivia();
if (Negate)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
right = LogicalNegationHelper.LogicallyNegate(right, semanticModel, cancellationToken);
}
ExpressionStatementSyntax newNode = SimpleAssignmentStatement(Left.WithoutTrivia(), right)
.WithTriviaFrom(IfStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(IfStatement, newNode, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
ConditionalExpressionSyntax conditionalExpression,
CancellationToken cancellationToken = default(CancellationToken))
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ConditionalExpressionSyntax newNode = conditionalExpression.Update(
condition: LogicalNegationHelper.LogicallyNegate(conditionalExpression.Condition, semanticModel, cancellationToken),
questionToken: conditionalExpression.QuestionToken,
whenTrue: conditionalExpression.WhenFalse.WithTriviaFrom(conditionalExpression.WhenTrue),
colonToken: conditionalExpression.ColonToken,
whenFalse: conditionalExpression.WhenTrue.WithTriviaFrom(conditionalExpression.WhenFalse));
newNode = newNode.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(conditionalExpression, newNode, cancellationToken).ConfigureAwait(false));
}
private SyntaxNode Rewrite(StatementsInfo statementsInfo, IfStatementSyntax ifStatement)
{
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(ifStatement);
ExpressionSyntax newCondition = LogicalNegationHelper.LogicallyNegate(ifStatement.Condition, _semanticModel, _cancellationToken);
if (_recursive)
{
ifStatement = (IfStatementSyntax)VisitIfStatement(ifStatement);
}
var block = (BlockSyntax)ifStatement.Statement;
BlockSyntax newBlock = block.WithStatements(SingletonList(_jumpStatement));
if (!block
.Statements
.First()
.GetLeadingTrivia()
.Any(f => f.IsEndOfLineTrivia()))
{
newBlock = newBlock.WithCloseBraceToken(newBlock.CloseBraceToken.AppendToTrailingTrivia(NewLine()));
}
IfStatementSyntax newIfStatement = ifStatement
.WithCondition(newCondition)
.WithStatement(newBlock)
.WithFormatterAnnotation();
if (statements.Last().Kind().IsJumpStatementOrYieldBreakStatement() &&
block.Statements.Last().Kind().IsJumpStatementOrYieldBreakStatement())
{
statements = statements.RemoveAt(statements.Count - 1);
}
SyntaxList <StatementSyntax> newStatements = statements
.ReplaceAt(index, newIfStatement)
.InsertRange(index + 1, block.Statements.Select(f => f.WithFormatterAnnotation()));
return(statementsInfo.WithStatements(newStatements).Node);
}
public static async Task <Document> RefactorAsync(
Document document,
IfStatementSyntax ifStatement,
CancellationToken cancellationToken = default(CancellationToken))
{
StatementSyntax trueStatement = ifStatement.Statement;
StatementSyntax falseStatement = ifStatement.Else.Statement;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
IfStatementSyntax newIfStatement = ifStatement
.WithCondition(LogicalNegationHelper.LogicallyNegate(ifStatement.Condition, semanticModel, cancellationToken))
.WithStatement(falseStatement.WithTriviaFrom(trueStatement))
.WithElse(ifStatement.Else.WithStatement(trueStatement.WithTriviaFrom(falseStatement)))
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false));
}
public static async Task <Document> RefactorAsync(
Document document,
InvocationExpressionSyntax invocationExpression,
string memberName,
ExpressionSyntax expression,
CancellationToken cancellationToken = default(CancellationToken))
{
var memberAccessExpression = (MemberAccessExpressionSyntax)invocationExpression.Expression;
MemberAccessExpressionSyntax newMemberAccessExpression = memberAccessExpression
.WithName(SyntaxFactory.IdentifierName(memberName).WithTriviaFrom(memberAccessExpression.Name));
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
InvocationExpressionSyntax newNode = invocationExpression
.ReplaceNode(expression, LogicalNegationHelper.LogicallyNegate(expression, semanticModel, cancellationToken))
.WithExpression(newMemberAccessExpression);
return(await document.ReplaceNodeAsync(invocationExpression, newNode, cancellationToken).ConfigureAwait(false));
}
public override async Task <Document> RefactorAsync(Document document, CancellationToken cancellationToken = default(CancellationToken))
{
ExpressionSyntax expression = Expression;
if (Negate)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
expression = LogicalNegationHelper.LogicallyNegate(expression, semanticModel, cancellationToken);
}
StatementSyntax statement = CreateStatement(expression);
if (IfStatement.IsSimpleIf())
{
StatementsInfo statementsInfo = SyntaxInfo.StatementsInfo(IfStatement);
SyntaxList <StatementSyntax> statements = statementsInfo.Statements;
int index = statements.IndexOf(IfStatement);
StatementSyntax newNode = statement
.WithLeadingTrivia(IfStatement.GetLeadingTrivia())
.WithTrailingTrivia(statements[index + 1].GetTrailingTrivia())
.WithFormatterAnnotation();
SyntaxList <StatementSyntax> newStatements = statements
.RemoveAt(index)
.ReplaceAt(index, newNode);
return(await document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken).ConfigureAwait(false));
}
else
{
StatementSyntax newNode = statement
.WithTriviaFrom(IfStatement)
.WithFormatterAnnotation();
return(await document.ReplaceNodeAsync(IfStatement, newNode, cancellationToken).ConfigureAwait(false));
}
}
private static async Task <ExpressionSyntax> CreateNewNodeAsync(
Document document,
BinaryExpressionSyntax binaryExpression,
CancellationToken cancellationToken)
{
ExpressionSyntax left = binaryExpression.Left;
ExpressionSyntax right = binaryExpression.Right;
TextSpan span = TextSpan.FromBounds(left.Span.End, right.Span.Start);
IEnumerable <SyntaxTrivia> trivia = binaryExpression.DescendantTrivia(span);
bool isWhiteSpaceOrEndOfLine = trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia());
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (left.Kind().IsBooleanLiteralExpression())
{
SyntaxTriviaList leadingTrivia = binaryExpression.GetLeadingTrivia();
if (!isWhiteSpaceOrEndOfLine)
{
leadingTrivia = leadingTrivia.AddRange(trivia);
}
if (right.IsKind(SyntaxKind.LogicalNotExpression))
{
var logicalNot = (PrefixUnaryExpressionSyntax)right;
ExpressionSyntax operand = logicalNot.Operand;
if (semanticModel.GetTypeInfo(operand, cancellationToken).ConvertedType.IsNullableOf(SpecialType.System_Boolean))
{
return(binaryExpression
.WithLeft(LogicalNegationHelper.LogicallyNegate(left, semanticModel, cancellationToken))
.WithRight(operand.WithTriviaFrom(right)));
}
}
return(LogicalNegationHelper.LogicallyNegate(right, semanticModel, cancellationToken)
.WithLeadingTrivia(leadingTrivia));
}
else if (right.Kind().IsBooleanLiteralExpression())
{
SyntaxTriviaList trailingTrivia = binaryExpression.GetTrailingTrivia();
if (!isWhiteSpaceOrEndOfLine)
{
trailingTrivia = trailingTrivia.InsertRange(0, trivia);
}
if (left.IsKind(SyntaxKind.LogicalNotExpression))
{
var logicalNot = (PrefixUnaryExpressionSyntax)left;
ExpressionSyntax operand = logicalNot.Operand;
if (semanticModel.GetTypeInfo(operand, cancellationToken).ConvertedType.IsNullableOf(SpecialType.System_Boolean))
{
return(binaryExpression
.WithLeft(operand.WithTriviaFrom(left))
.WithRight(LogicalNegationHelper.LogicallyNegate(right, semanticModel, cancellationToken)));
}
}
return(LogicalNegationHelper.LogicallyNegate(left, semanticModel, cancellationToken)
.WithTrailingTrivia(trailingTrivia));
}
Debug.Fail(binaryExpression.ToString());
return(binaryExpression);
}