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(Negator.LogicallyNegate(ifStatement.Condition, semanticModel, cancellationToken)) .WithStatement(whenFalse.WithTriviaFrom(whenTrue)) .WithElse(newElseClause) .WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false)); }
private static Task <Document> RefactorAsync( Document document, ExpressionSyntax expression, CancellationToken cancellationToken) { return(document.ReplaceNodeAsync(expression, Negator.LogicallyNegate(expression), cancellationToken)); }
private static async Task <Document> InvertIfElseAsync( Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken = default(CancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); ElseClauseSyntax elseClause = ifStatement.Else; StatementSyntax whenTrue = ifStatement.Statement; StatementSyntax whenFalse = elseClause.Statement; SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); IfStatementSyntax newIfStatement = ifStatement.Update( ifKeyword: ifStatement.IfKeyword, openParenToken: ifStatement.OpenParenToken, condition: Negator.LogicallyNegate(ifStatement.Condition, semanticModel, cancellationToken), closeParenToken: ifStatement.CloseParenToken, statement: whenFalse.WithTriviaFrom(whenTrue), @else: elseClause.WithStatement(whenTrue.WithTriviaFrom(whenFalse))); newIfStatement = newIfStatement.WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken).ConfigureAwait(false)); }
private static async Task <Document> RefactorAsync( Document document, ExpressionSyntax expression, CancellationToken cancellationToken) { return(await document.ReplaceNodeAsync(expression, Negator.LogicallyNegate(expression), cancellationToken).ConfigureAwait(false)); }
private void EliminateViaIf(IfStatement gotoStatement, Statement labeledStatement) { V_0 = labeledStatement.get_Parent() as BlockStatement; V_1 = V_0.get_Statements().IndexOf(gotoStatement); V_2 = V_0.get_Statements().IndexOf(labeledStatement); if (V_1 == V_2 - 1) { V_0.get_Statements().RemoveAt(V_1); return; } V_3 = this.CollectStatements(V_1 + 1, V_2, V_0); V_4 = Negator.Negate(gotoStatement.get_Condition(), this.typeSystem); while (V_3.get_Statements().get_Item(0) as IfStatement != null) { V_5 = V_3.get_Statements().get_Item(0) as IfStatement; if (!this.AreEqual(V_5.get_Condition(), V_4) || V_5.get_Else() != null) { break; } V_3.get_Statements().RemoveAt(0); V_6 = 0; while (V_6 < V_5.get_Then().get_Statements().get_Count()) { V_3.AddStatement(V_5.get_Then().get_Statements().get_Item(V_6)); V_6 = V_6 + 1; } } gotoStatement.set_Then(V_3); gotoStatement.set_Condition(V_4); return; }
public static async Task <Document> RefactorAsync( Document document, ConditionalExpressionSyntax conditionalExpression, CancellationToken cancellationToken) { ExpressionSyntax condition = conditionalExpression.Condition; ExpressionSyntax newNode = (conditionalExpression.WhenTrue.IsKind(SyntaxKind.TrueLiteralExpression)) ? condition : Negator.LogicallyNegate(condition); TextSpan span = TextSpan.FromBounds( conditionalExpression.Condition.Span.End, conditionalExpression.FullSpan.End); IEnumerable <SyntaxTrivia> trivia = conditionalExpression.DescendantTrivia(span); if (trivia.Any(f => !f.IsWhitespaceOrEndOfLineTrivia())) { newNode = newNode.WithTrailingTrivia(trivia); } else { newNode = newNode.WithoutTrailingTrivia(); } return(await document.ReplaceNodeAsync(conditionalExpression, newNode, cancellationToken).ConfigureAwait(false)); }
public override SyntaxNode VisitBlock(BlockSyntax node) { node = (BlockSyntax)base.VisitBlock(node); SyntaxList <StatementSyntax> statements = node.Statements; var ifStatement = statements.LastOrDefault(f => !f.IsKind(SyntaxKind.LocalFunctionStatement)) as IfStatementSyntax; if (ifStatement != null && IsFixable(ifStatement) && ((BlockSyntax)ifStatement.Parent).Statements.IsLastStatement(ifStatement, skipLocalFunction: true)) { var block = (BlockSyntax)ifStatement.Statement; ExpressionSyntax newCondition = Negator.LogicallyNegate(ifStatement.Condition); IfStatementSyntax newIfStatement = ifStatement .WithCondition(newCondition) .WithStatement(block.WithStatements(SingletonList(_jumpStatement))) .WithFormatterAnnotation(); int index = statements.IndexOf(ifStatement); SyntaxList <StatementSyntax> newStatements = statements .ReplaceAt(index, newIfStatement) .InsertRange(index + 1, block.Statements.Select(f => f.WithFormatterAnnotation())); node = node.WithStatements(newStatements); } return(node); }
private void CleanupEmptyIfs(BlockStatement body) { do { V_0 = this.emptyThenIfs.GetEnumerator(); try { while (V_0.MoveNext()) { V_1 = V_0.get_Current(); if (V_1.get_Else() == null || V_1.get_Else().get_Statements().get_Count() == 0) { dummyVar0 = (V_1.get_Parent() as BlockStatement).get_Statements().Remove(V_1); } else { V_1.set_Then(V_1.get_Else()); V_1.set_Else(null); dummyVar1 = Negator.Negate(V_1.get_Condition(), this.typeSystem); } } } finally { ((IDisposable)V_0).Dispose(); } this.emptyThenIfs = new List <IfStatement>(); this.Visit(body); }while (this.emptyThenIfs.get_Count() != 0); return; }
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 : Negator.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 override SyntaxNode VisitBlock(BlockSyntax node) { _block = node; if (node.LastStatementOrDefault(skipLocalFunction: true) is IfStatementSyntax ifStatement && IsFixable(ifStatement)) { SyntaxList <StatementSyntax> statements = node.Statements; int index = statements.IndexOf(ifStatement); ifStatement = (IfStatementSyntax)VisitIfStatement(ifStatement); var block = (BlockSyntax)ifStatement.Statement; ExpressionSyntax newCondition = Negator.LogicallyNegate(ifStatement.Condition); IfStatementSyntax newIfStatement = ifStatement .WithCondition(newCondition) .WithStatement(block.WithStatements(SingletonList(_jumpStatement))) .WithFormatterAnnotation(); SyntaxList <StatementSyntax> newStatements = statements .ReplaceAt(index, newIfStatement) .InsertRange(index + 1, block.Statements.Select(f => f.WithFormatterAnnotation())); node = node.WithStatements(newStatements); } return(node); }
public void Negate(TypeSystem typeSystem) { V_0 = this.get_TrueCFGSuccessor(); this.set_TrueCFGSuccessor(this.get_FalseCFGSuccessor()); this.set_FalseCFGSuccessor(V_0); this.set_ConditionExpression(Negator.Negate(this.get_ConditionExpression(), typeSystem)); return; }
/// <summary> /// Negates the expression of the construct and switches the true and false successors. /// </summary> public void Negate(TypeSystem typeSystem) { CFGBlockLogicalConstruct successorHolder = TrueCFGSuccessor; TrueCFGSuccessor = FalseCFGSuccessor; FalseCFGSuccessor = successorHolder; ConditionExpression = Negator.Negate(ConditionExpression, typeSystem); }
public static Task <Document> RefactorAsync( Document document, BinaryExpressionSyntax binaryExpression, CancellationToken cancellationToken = default(CancellationToken)) { ExpressionSyntax newNode = Negator.LogicallyNegate(binaryExpression) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(binaryExpression, newNode, cancellationToken)); }
private static async Task <Document> RefactorAsync( Document document, ExpressionSyntax expression, CancellationToken cancellationToken) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); ExpressionSyntax newNode = Negator.LogicallyNegate(expression, semanticModel, cancellationToken); return(await document.ReplaceNodeAsync(expression, newNode, cancellationToken).ConfigureAwait(false)); }
private static Task <Document> IfToReturnWithExpressionAsync( Document document, IfToReturnWithExpressionAnalysis analysis, CancellationToken cancellationToken = default(CancellationToken)) { ExpressionSyntax expression = analysis.Expression; if (analysis.Negate) { expression = Negator.LogicallyNegate(expression, analysis.SemanticModel, cancellationToken); } StatementSyntax statement; if (analysis.IsYield) { statement = YieldReturnStatement(expression); } else { statement = ReturnStatement(expression); } IfStatementSyntax ifStatement = analysis.IfStatement; if (ifStatement.IsSimpleIf()) { StatementListInfo statementsInfo = SyntaxInfo.StatementListInfo(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(document.ReplaceStatementsAsync(statementsInfo, newStatements, cancellationToken)); } else { StatementSyntax newNode = statement .WithTriviaFrom(ifStatement) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(ifStatement, newNode, cancellationToken)); } }
public static async Task <Document> RefactorAsync( Document document, BinaryExpressionSyntax binaryExpression, CancellationToken cancellationToken = default(CancellationToken)) { SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); ExpressionSyntax newNode = Negator.LogicallyNegate(binaryExpression, semanticModel, cancellationToken); newNode = newNode.WithFormatterAnnotation(); return(await document.ReplaceNodeAsync(binaryExpression, newNode, cancellationToken).ConfigureAwait(false)); }
public static Task <Document> RefactorAsync( Document document, ConditionalExpressionSyntax conditionalExpression, CancellationToken cancellationToken = default(CancellationToken)) { ConditionalExpressionSyntax newConditionalExpression = conditionalExpression .WithCondition(Negator.LogicallyNegate(conditionalExpression.Condition)) .WithWhenTrue(conditionalExpression.WhenFalse.WithTriviaFrom(conditionalExpression.WhenTrue)) .WithWhenFalse(conditionalExpression.WhenTrue.WithTriviaFrom(conditionalExpression.WhenFalse)) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(conditionalExpression, newConditionalExpression, cancellationToken)); }
public static ExpressionSyntax GetBooleanExpression(ExpressionSyntax condition, ExpressionSyntax expression1, ExpressionSyntax expression2) { 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)); case SyntaxKind.FalseLiteralExpression: return(expression2); default: return(LogicalOrExpression(Negator.LogicallyNegate(condition), expression2)); } } default: { switch (expression2.Kind()) { case SyntaxKind.TrueLiteralExpression: return(LogicalOrExpression(Negator.LogicallyNegate(condition), expression1)); case SyntaxKind.FalseLiteralExpression: return(LogicalAndExpression(condition.Parenthesize().WithSimplifierAnnotation(), expression1.Parenthesize().WithSimplifierAnnotation())); default: return(LogicalOrExpression(ParenthesizedExpression(LogicalAndExpression(condition, expression1)), expression2)); } } } }
public static async Task <Document> RefactorAsync( Document document, BinaryExpressionSyntax binaryExpression, CancellationToken cancellationToken) { ExpressionSyntax left = binaryExpression.Left; ExpressionSyntax right = binaryExpression.Right; SyntaxToken operatorToken = binaryExpression.OperatorToken; ExpressionSyntax newNode = binaryExpression; TextSpan span = TextSpan.FromBounds(left.Span.End, right.Span.Start); IEnumerable <SyntaxTrivia> trivia = binaryExpression.DescendantTrivia(span); bool isWhiteSpaceOrEndOfLine = trivia.All(f => f.IsWhitespaceOrEndOfLineTrivia()); if (left.IsBooleanLiteralExpression()) { SyntaxTriviaList leadingTrivia = binaryExpression.GetLeadingTrivia(); if (!isWhiteSpaceOrEndOfLine) { leadingTrivia = leadingTrivia.AddRange(trivia); } newNode = Negator.LogicallyNegate(right) .WithLeadingTrivia(leadingTrivia); } else if (right.IsBooleanLiteralExpression()) { SyntaxTriviaList trailingTrivia = binaryExpression.GetTrailingTrivia(); if (!isWhiteSpaceOrEndOfLine) { trailingTrivia = trailingTrivia.InsertRange(0, trivia); } newNode = Negator.LogicallyNegate(left) .WithTrailingTrivia(trailingTrivia); } #if DEBUG else { Debug.Assert(false, binaryExpression.ToString()); } #endif return(await document.ReplaceNodeAsync(binaryExpression, newNode.WithFormatterAnnotation(), cancellationToken).ConfigureAwait(false)); }
public override ICodeNode VisitUnaryExpression(UnaryExpression node) { if (this.status == 2) { throw new Exception("Invalid state"); } V_0 = node.get_Operand(); node.set_Operand((Expression)this.Visit(node.get_Operand())); if (node.get_Operator() != 1 || V_0 == node.get_Operand()) { return(node); } return(Negator.Negate(node.get_Operand(), this.typeSystem)); }
private static ReturnStatementSyntax CreateReturnStatement(IfStatementSyntax ifStatement) { ExpressionSyntax expression = ifStatement.Condition; if (GetBooleanLiteral(ifStatement.Statement).IsKind(SyntaxKind.FalseLiteralExpression)) { expression = Negator.LogicallyNegate(expression); } return(ReturnStatement( ReturnKeyword().WithTrailingTrivia(Space), expression, SemicolonToken())); }
public static ExpressionSyntax GetExpression(ExpressionSyntax condition, ExpressionSyntax expression1, ExpressionSyntax expression2) { 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)); case SyntaxKind.FalseLiteralExpression: return(expression2); default: return(LogicalOrExpression(Negator.LogicallyNegate(condition), expression2)); } } default: { switch (expression2.Kind()) { case SyntaxKind.TrueLiteralExpression: return(LogicalOrExpression(Negator.LogicallyNegate(condition), expression1)); case SyntaxKind.FalseLiteralExpression: return(LogicalAndExpression(condition, expression1, addParenthesesIfNecessary: true)); default: return(LogicalOrExpression(ParenthesizedExpression(LogicalAndExpression(condition, expression1)), expression2)); } } } }
public static ExpressionSyntax GetBooleanExpression(ExpressionSyntax condition, ExpressionSyntax expression1, ExpressionSyntax expression2) { 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)); case SyntaxKind.FalseLiteralExpression: return(expression2); default: return(LogicalAndExpression(Negator.LogicallyNegate(condition), expression2)); } } default: { switch (expression2.Kind()) { case SyntaxKind.TrueLiteralExpression: return(LogicalOrExpression(Negator.LogicallyNegate(condition), expression1)); case SyntaxKind.FalseLiteralExpression: return(LogicalAndExpression(condition, expression1)); default: throw new InvalidOperationException(); } } } }
public static Task <Document> RefactorAsync( Document document, ConditionalExpressionSyntax conditionalExpression, CancellationToken cancellationToken = default(CancellationToken)) { ConditionalExpressionSyntax newNode = conditionalExpression.Update( condition: Negator.LogicallyNegate(conditionalExpression.Condition), questionToken: conditionalExpression.QuestionToken, whenTrue: conditionalExpression.WhenFalse.WithTriviaFrom(conditionalExpression.WhenTrue), colonToken: conditionalExpression.ColonToken, whenFalse: conditionalExpression.WhenTrue.WithTriviaFrom(conditionalExpression.WhenFalse)); newNode = newNode.WithFormatterAnnotation(); return(document.ReplaceNodeAsync(conditionalExpression, newNode, cancellationToken)); }
public static Task <Document> RefactorAsync( Document document, IfStatementSyntax ifStatement, CancellationToken cancellationToken = default(CancellationToken)) { StatementSyntax trueStatement = ifStatement.Statement; StatementSyntax falseStatement = ifStatement.Else.Statement; IfStatementSyntax newIfStatement = ifStatement .WithCondition(Negator.LogicallyNegate(ifStatement.Condition)) .WithStatement(falseStatement.WithTriviaFrom(trueStatement)) .WithElse(ifStatement.Else.WithStatement(trueStatement.WithTriviaFrom(falseStatement))) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(ifStatement, newIfStatement, cancellationToken)); }
public override ICodeNode VisitUnaryExpression(UnaryExpression node) { if (status == InliningResult.Abort) { //sanity check throw new Exception("Invalid state"); } Expression originalOperand = node.Operand; node.Operand = (Expression)Visit(node.Operand); if (node.Operator == UnaryOperator.LogicalNot && originalOperand != node.Operand) { return(Negator.Negate(node.Operand, typeSystem)); } return(node); }
public override SyntaxNode VisitBlock(BlockSyntax node) { _block = node; if (node.LastStatementOrDefault(skipLocalFunction: true) is IfStatementSyntax ifStatement && IsFixable(ifStatement)) { SyntaxList <StatementSyntax> statements = node.Statements; int index = statements.IndexOf(ifStatement); if (_recursive) { ifStatement = (IfStatementSyntax)VisitIfStatement(ifStatement); } var block = (BlockSyntax)ifStatement.Statement; ExpressionSyntax newCondition = Negator.LogicallyNegate(ifStatement.Condition); 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(); SyntaxList <StatementSyntax> newStatements = statements .ReplaceAt(index, newIfStatement) .InsertRange(index + 1, block.Statements.Select(f => f.WithFormatterAnnotation())); node = node.WithStatements(newStatements); } return(node); }
public static 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)); InvocationExpressionSyntax newNode = invocationExpression .ReplaceNode(expression, Negator.LogicallyNegate(expression)) .WithExpression(newMemberAccessExpression); return(document.ReplaceNodeAsync(invocationExpression, newNode, cancellationToken)); }
private static Task <Document> IfElseToAssignmentWithConditionAsync( Document document, IfElseToAssignmentWithConditionAnalysis analysis, CancellationToken cancellationToken = default(CancellationToken)) { ExpressionSyntax right = analysis.Right.WithoutTrivia(); if (analysis.Negate) { right = Negator.LogicallyNegate(right, analysis.SemanticModel, cancellationToken); } ExpressionStatementSyntax newNode = SimpleAssignmentStatement(analysis.Left.WithoutTrivia(), right) .WithTriviaFrom(analysis.IfStatement) .WithFormatterAnnotation(); return(document.ReplaceNodeAsync(analysis.IfStatement, newNode, cancellationToken)); }
private SyntaxNode Rewrite(StatementListInfo statementsInfo, IfStatementSyntax ifStatement) { SyntaxList <StatementSyntax> statements = statementsInfo.Statements; int index = statements.IndexOf(ifStatement); ExpressionSyntax newCondition = Negator.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 (CSharpFacts.IsJumpStatementOrYieldBreakStatement(statements.Last().Kind()) && CSharpFacts.IsJumpStatementOrYieldBreakStatement(block.Statements.Last().Kind())) { 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).Parent); }