public static void ComputeRefactoring(RefactoringContext context, SelectedStatementsInfo info) { if (info.IsSingleSelected) { StatementSyntax[] statements = info.SelectedNodes().ToArray(); StatementSyntax first = statements[0]; if (first.IsKind(SyntaxKind.IfStatement)) { var ifStatement = (IfStatementSyntax)first; if (IfElseAnalysis.IsTopmostIf(ifStatement) && CanBeReplacedWithSwitch(ifStatement)) { string title = (IfElseAnalysis.IsIsolatedIf(ifStatement)) ? "Replace if with switch" : "Replace if-else with switch"; context.RegisterRefactoring( title, cancellationToken => { return(RefactorAsync( context.Document, ifStatement, cancellationToken)); }); } } } }
private static bool CheckContainingNode(SyntaxNode node) { switch (node.Kind()) { case SyntaxKind.ForEachStatement: case SyntaxKind.ForStatement: case SyntaxKind.UsingStatement: case SyntaxKind.WhileStatement: case SyntaxKind.DoStatement: case SyntaxKind.LockStatement: case SyntaxKind.FixedStatement: case SyntaxKind.UnsafeStatement: case SyntaxKind.TryStatement: case SyntaxKind.CheckedStatement: case SyntaxKind.UncheckedStatement: return(true); case SyntaxKind.IfStatement: return(IfElseAnalysis.IsTopmostIf((IfStatementSyntax)node)); case SyntaxKind.ElseClause: return(IfElseAnalysis.IsEndOfChain((ElseClauseSyntax)node)); } return(false); }
public static bool CanRefactor( IfStatementSyntax ifStatement, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { if (IfElseAnalysis.IsTopmostIf(ifStatement)) { ElseClauseSyntax elseClause = ifStatement.Else; if (elseClause != null) { ExpressionSyntax condition = ifStatement.Condition; if (condition != null) { ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(condition, cancellationToken); if (typeSymbol?.IsBoolean() == true) { AssignmentExpressionSyntax trueExpression = GetSimpleAssignmentExpression(ifStatement.Statement); ExpressionSyntax trueRight = trueExpression?.Right; if (trueRight?.IsBooleanLiteralExpression() == true) { AssignmentExpressionSyntax falseExpression = GetSimpleAssignmentExpression(elseClause.Statement); ExpressionSyntax falseRight = falseExpression?.Right; if (falseRight?.IsBooleanLiteralExpression() == true) { var trueBooleanLiteral = (LiteralExpressionSyntax)trueRight; var falseBooleanLiteral = (LiteralExpressionSyntax)falseRight; if (trueBooleanLiteral.IsKind(SyntaxKind.TrueLiteralExpression) != falseBooleanLiteral.IsKind(SyntaxKind.TrueLiteralExpression) && trueExpression.Left?.IsEquivalentTo(falseExpression.Left, topLevel: false) == true) { return(true); } } } } } } } return(false); }
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IfStatementSyntax ifStatement) { if (context.IsAnyRefactoringEnabled( RefactoringIdentifiers.SwapStatementsInIfElse, RefactoringIdentifiers.ReplaceIfElseWithConditionalExpression) && IfElseAnalysis.IsTopmostIf(ifStatement) && context.Span.IsBetweenSpans(ifStatement)) { if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfElseWithConditionalExpression)) { ReplaceIfElseWithConditionalExpressionRefactoring.ComputeRefactoring(context, ifStatement); } if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapStatementsInIfElse) && SwapStatementInIfElseRefactoring.CanRefactor(ifStatement)) { context.RegisterRefactoring( "Swap statements in if-else", cancellationToken => { return(SwapStatementInIfElseRefactoring.RefactorAsync( context.Document, ifStatement, cancellationToken)); }); } } if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddBooleanComparison) && ifStatement.Condition != null && ifStatement.Condition.Span.Contains(context.Span) && context.SupportsSemanticModel) { await AddBooleanComparisonRefactoring.ComputeRefactoringAsync(context, ifStatement.Condition).ConfigureAwait(false); } }
public static void ComputeRefactoring(RefactoringContext context, IfStatementSyntax ifStatement) { if (IfElseAnalysis.IsTopmostIf(ifStatement)) { ElseClauseSyntax elseClause = ifStatement.Else; if (elseClause != null) { StatementSyntax statement2 = elseClause.Statement; if (statement2?.IsKind(SyntaxKind.IfStatement) == false) { StatementSyntax statement1 = GetStatementOrDefault(ifStatement.Statement); if (statement1 != null) { statement2 = GetStatementOrDefault(statement2); if (statement2 != null) { SyntaxKind kind1 = statement1.Kind(); SyntaxKind kind2 = statement2.Kind(); if (kind1 == SyntaxKind.ReturnStatement) { if (kind2 == SyntaxKind.ReturnStatement) { ComputeRefactoring( context, ifStatement, (ReturnStatementSyntax)statement1, (ReturnStatementSyntax)statement2); } } else if (kind1 == SyntaxKind.YieldReturnStatement) { if (kind2 == SyntaxKind.YieldReturnStatement) { ComputeRefactoring( context, ifStatement, (YieldStatementSyntax)statement1, (YieldStatementSyntax)statement2); } } else if (kind1 == SyntaxKind.ExpressionStatement) { if (kind2 == SyntaxKind.ExpressionStatement) { ComputeRefactoring( context, ifStatement, (ExpressionStatementSyntax)statement1, (ExpressionStatementSyntax)statement2); } } } } } } } }
private static StatementSyntax GetStatement( RefactoringContext context, BlockSyntax block, SyntaxNode parent) { switch (parent?.Kind()) { case SyntaxKind.WhileStatement: case SyntaxKind.DoStatement: case SyntaxKind.ForStatement: case SyntaxKind.ForEachStatement: case SyntaxKind.FixedStatement: case SyntaxKind.CheckedStatement: case SyntaxKind.UncheckedStatement: case SyntaxKind.UnsafeStatement: case SyntaxKind.UsingStatement: case SyntaxKind.LockStatement: { if (block.OpenBraceToken.Span.Contains(context.Span) || block.CloseBraceToken.Span.Contains(context.Span)) { if (parent.IsKind(SyntaxKind.UsingStatement)) { var usingStatement = (UsingStatementSyntax)parent; while (usingStatement.Parent?.IsKind(SyntaxKind.UsingStatement) == true) { usingStatement = (UsingStatementSyntax)usingStatement.Parent; } return(usingStatement); } return((StatementSyntax)parent); } break; } case SyntaxKind.TryStatement: { var tryStatement = (TryStatementSyntax)parent; if (tryStatement.Block?.OpenBraceToken.Span.Contains(context.Span) == true) { return((StatementSyntax)parent); } break; } case SyntaxKind.IfStatement: { var ifStatement = (IfStatementSyntax)parent; if (IfElseAnalysis.IsTopmostIf(ifStatement) && block.OpenBraceToken.Span.Contains(context.Span)) { return(ifStatement); } if (ifStatement.Else == null && block.CloseBraceToken.Span.Contains(context.Span)) { return(ifStatement); } break; } case SyntaxKind.ElseClause: { var elseClause = (ElseClauseSyntax)parent; if (block.CloseBraceToken.Span.Contains(context.Span)) { return(IfElseAnalysis.GetTopmostIf(elseClause)); } break; } case SyntaxKind.CatchClause: { var catchClause = (CatchClauseSyntax)parent; if (catchClause.Parent?.IsKind(SyntaxKind.TryStatement) == true) { var tryStatement = (TryStatementSyntax)catchClause.Parent; if (tryStatement.Finally == null && catchClause.Block?.CloseBraceToken.Span.Contains(context.Span) == true) { return(tryStatement); } } break; } case SyntaxKind.FinallyClause: { var finallyClause = (FinallyClauseSyntax)parent; if (finallyClause.Parent?.IsKind(SyntaxKind.TryStatement) == true) { var tryStatement = (TryStatementSyntax)finallyClause.Parent; if (finallyClause.Block?.CloseBraceToken.Span.Contains(context.Span) == true) { return(tryStatement); } } break; } } return(null); }