public static async Task ComputeRefactoringsAsync(RefactoringContext context, IfStatementSyntax ifStatement)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.SwapStatementsInIfElse,
RefactoringIdentifiers.ReplaceIfElseWithAssignment,
RefactoringIdentifiers.ReplaceIfStatementWithReturnStatement,
RefactoringIdentifiers.ReplaceIfElseWithSwitch) &&
IfElseChain.IsTopmostIf(ifStatement) &&
context.Span.IsBetweenSpans(ifStatement))
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfStatementWithReturnStatement))
{
await ReplaceIfWithStatementRefactoring.ComputeRefactoringAsync(context, ifStatement).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfElseWithAssignment))
{
ReplaceIfElseWithAssignmentRefactoring.ComputeRefactoring(context, ifStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapStatementsInIfElse))
{
SwapStatementInIfElseRefactoring.ComputeRefactoring(context, ifStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfElseWithSwitch))
{
await ReplaceIfElseWithSwitchRefactoring.ComputeRefactoringAsync(context, ifStatement).ConfigureAwait(false);
}
}
}
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(IfElseChain.IsTopmostIf((IfStatementSyntax)node));
case SyntaxKind.ElseClause:
return(IfElseChain.IsEndOfChain((ElseClauseSyntax)node));
}
return(false);
}
public static void Analyze(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (!node.IsKind(SyntaxKind.IfStatement) ||
!IfElseChain.IsPartOfChain((IfStatementSyntax)node))
{
BlockSyntax block = GetBlockThatCanBeEmbeddedStatement(node);
if (block != null)
{
SyntaxToken openBrace = block.OpenBraceToken;
SyntaxToken closeBrace = block.CloseBraceToken;
if (!openBrace.IsMissing &&
!closeBrace.IsMissing &&
openBrace.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()) &&
closeBrace.GetLeadingAndTrailingTrivia().All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(
DiagnosticDescriptors.RemoveBraces,
block,
GetName(node));
context.ReportBraces(DiagnosticDescriptors.RemoveBracesFadeOut, block);
}
}
}
}
private static HashSet <AwaitExpressionSyntax> GetAwaitExpressionsFromIfStatement(
IfStatementSyntax ifStatement,
bool endsWithElse)
{
HashSet <AwaitExpressionSyntax> awaitExpressions = null;
foreach (IfStatementOrElseClause ifOrElse in IfElseChain.GetChain(ifStatement))
{
if (ifOrElse.IsElse &&
!endsWithElse)
{
return(null);
}
AwaitExpressionSyntax awaitExpression = GetLastReturnAwaitExpressionOfDefault(ifOrElse.Statement);
if (awaitExpression != null)
{
(awaitExpressions ?? (awaitExpressions = new HashSet <AwaitExpressionSyntax>())).Add(awaitExpression);
}
else
{
return(null);
}
}
return(awaitExpressions);
}
private static IEnumerable <SwitchSectionSyntax> CreateSwitchSections(IfStatementSyntax ifStatement)
{
foreach (SyntaxNode node in IfElseChain.GetChain(ifStatement))
{
if (node.IsKind(SyntaxKind.IfStatement))
{
ifStatement = (IfStatementSyntax)node;
var condition = ifStatement.Condition as BinaryExpressionSyntax;
List <SwitchLabelSyntax> labels = CreateSwitchLabels(condition, new List <SwitchLabelSyntax>());
labels.Reverse();
SwitchSectionSyntax section = SwitchSection(
List(labels),
AddBreakStatementIfNecessary(ifStatement.Statement));
yield return(section);
}
else
{
var elseClause = (ElseClauseSyntax)node;
yield return(DefaultSwitchSection(AddBreakStatementIfNecessary(elseClause.Statement)));
}
}
}
public override SyntaxNode VisitIfStatement(IfStatementSyntax node)
{
if (node == null)
{
throw new ArgumentNullException(nameof(node));
}
if (_previousIf == null || _previousIf.Equals(IfElseChain.GetPreviousIf(node)))
{
if (node.Statement != null &&
!node.Statement.IsKind(SyntaxKind.Block))
{
IfStatementSyntax ifStatement = node.WithStatement(SyntaxFactory.Block(node.Statement));
_previousIf = ifStatement;
return(base.VisitIfStatement(ifStatement));
}
else
{
_previousIf = node;
}
}
return(base.VisitIfStatement(node));
}
private static IEnumerable <SwitchSectionSyntax> CreateSwitchSections(IfStatementSyntax ifStatement)
{
foreach (IfStatementOrElseClause ifOrElse in IfElseChain.GetChain(ifStatement))
{
if (ifOrElse.IsIf)
{
ifStatement = ifOrElse.AsIf();
var condition = ifStatement.Condition as BinaryExpressionSyntax;
List <SwitchLabelSyntax> labels = CreateSwitchLabels(condition, new List <SwitchLabelSyntax>());
labels.Reverse();
SwitchSectionSyntax section = SwitchSection(
List(labels),
AddBreakStatementIfNecessary(ifStatement.Statement));
yield return(section);
}
else
{
yield return(DefaultSwitchSection(AddBreakStatementIfNecessary(ifOrElse.Statement)));
}
}
}
public static async Task <Document> RefactorAsync(
Document document,
StatementSyntax statement,
CancellationToken cancellationToken = default(CancellationToken))
{
IEnumerable <StatementSyntax> newNodes = GetNewNodes(statement)
.Select(f => f.WithFormatterAnnotation());
if (statement.Parent.IsKind(SyntaxKind.ElseClause))
{
IfStatementSyntax ifStatement = IfElseChain.GetTopmostIf((ElseClauseSyntax)statement.Parent);
var block = (BlockSyntax)ifStatement.Parent;
int index = block.Statements.IndexOf(ifStatement);
BlockSyntax newBlock = block.RemoveNode(statement.Parent, SyntaxRemoveOptions.KeepNoTrivia);
newBlock = newBlock.WithStatements(newBlock.Statements.InsertRange(index + 1, newNodes));
return(await document.ReplaceNodeAsync(block, newBlock, cancellationToken).ConfigureAwait(false));
}
else
{
return(await document.ReplaceNodeAsync(statement.Parent, newNodes, cancellationToken).ConfigureAwait(false));
}
}
private static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
SyntaxNode node = context.Node;
if (IfElseChain.IsPartOfChain((IfStatementSyntax)node))
{
Analyze(context, node);
}
}
public static BracesAnalysisResult AnalyzeBraces(IfStatementSyntax ifStatement)
{
if (ifStatement == null)
{
throw new ArgumentNullException(nameof(ifStatement));
}
bool anyHasEmbedded = false;
bool anyHasBlock = false;
bool allSupportsEmbedded = true;
int cnt = 0;
foreach (IfStatementOrElseClause ifOrElse in IfElseChain.GetChain(ifStatement))
{
cnt++;
StatementSyntax statement = ifOrElse.Statement;
if (!anyHasEmbedded && !statement.IsKind(SyntaxKind.Block))
{
anyHasEmbedded = true;
}
if (!anyHasBlock && statement.IsKind(SyntaxKind.Block))
{
anyHasBlock = true;
}
if (allSupportsEmbedded && !SupportsEmbedded(statement))
{
allSupportsEmbedded = false;
}
if (cnt > 1 && anyHasEmbedded && !allSupportsEmbedded)
{
return(BracesAnalysisResult.AddBraces);
}
}
if (cnt > 1 &&
allSupportsEmbedded &&
anyHasBlock)
{
if (anyHasEmbedded)
{
return(BracesAnalysisResult.AddBraces | BracesAnalysisResult.RemoveBraces);
}
else
{
return(BracesAnalysisResult.RemoveBraces);
}
}
return(BracesAnalysisResult.None);
}
private static IEnumerable <IfStatementSyntax> GetIfStatements(IfStatementSyntax ifStatement)
{
foreach (IfStatementOrElseClause ifOrElse in IfElseChain.GetChain(ifStatement))
{
if (ifOrElse.IsIf)
{
yield return(ifOrElse.AsIf());
}
}
}
private static SyntaxNode GetContainingBlock(SyntaxNode node)
{
if (node.IsKind(SyntaxKind.ElseClause))
{
return(IfElseChain.GetTopmostIf((ElseClauseSyntax)node)?.Parent);
}
else
{
return(node.Parent);
}
}
private static IEnumerable <StatementSyntax> GetEmbeddedStatements(IfStatementSyntax topmostIf)
{
foreach (IfStatementOrElseClause ifOrElse in IfElseChain.GetChain(topmostIf))
{
StatementSyntax statement = ifOrElse.Statement;
if (statement?.IsKind(SyntaxKind.Block) == false)
{
yield return(statement);
}
}
}
public static void ComputeRefactoring(RefactoringContext context, SelectedStatementCollection selectedStatements)
{
if (selectedStatements.Count == 2)
{
StatementSyntax[] statements = selectedStatements.ToArray();
if (statements[0].IsKind(SyntaxKind.IfStatement) &&
statements[1].IsKind(SyntaxKind.ReturnStatement))
{
var ifStatement = (IfStatementSyntax)statements[0];
if (!IfElseChain.IsPartOfChain(ifStatement))
{
ExpressionSyntax returnExpression = ReplaceIfWithStatementRefactoring.GetReturnExpression(ifStatement);
if (returnExpression != null)
{
var returnStatement = (ReturnStatementSyntax)statements[1];
ExpressionSyntax returnExpression2 = returnStatement.Expression;
if (returnExpression2 != null)
{
const string title = "Replace if-return with return";
if (returnExpression.IsBooleanLiteralExpression() ||
returnExpression2.IsBooleanLiteralExpression())
{
context.RegisterRefactoring(
title,
cancellationToken => RefactorAsync(context.Document, selectedStatements.Container, ifStatement, returnStatement, cancellationToken));
}
else
{
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(RefactorAsync(
context.Document,
selectedStatements.Container,
ifStatement,
returnStatement,
returnExpression,
returnExpression2,
cancellationToken));
});
}
}
}
}
}
}
}
private static IEnumerable <BlockSyntax> GetBlockStatements(IfStatementSyntax ifStatement)
{
foreach (IfStatementOrElseClause ifOrElse in IfElseChain.GetChain(ifStatement))
{
StatementSyntax statement = ifOrElse.Statement;
if (statement?.IsKind(SyntaxKind.Block) == true)
{
yield return((BlockSyntax)statement);
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, ContinueStatementSyntax continueStatement)
{
SyntaxNode parent = continueStatement.Parent;
if (parent?.IsKind(SyntaxKind.Block) == true)
{
var block = (BlockSyntax)parent;
parent = parent.Parent;
if (parent != null)
{
SyntaxKind kind = parent.Kind();
if (CanContainContinueStatement(kind))
{
if (block.Statements.IsLast(continueStatement) &&
!continueStatement.SpanContainsDirectives())
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantContinueStatement, continueStatement);
}
}
else if (kind == SyntaxKind.ElseClause)
{
var elseClause = (ElseClauseSyntax)parent;
if (IfElseChain.IsEndOfChain(elseClause))
{
IfStatementSyntax ifStatement = IfElseChain.GetTopmostIf(elseClause);
parent = ifStatement.Parent;
if (parent?.IsKind(SyntaxKind.Block) == true)
{
block = (BlockSyntax)parent;
parent = parent.Parent;
if (CanContainContinueStatement(parent) &&
block.Statements.IsLast(ifStatement) &&
!elseClause.SpanContainsDirectives())
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantContinueStatement, continueStatement);
}
}
}
}
}
}
}
public static bool CanRefactor(
IfStatementSyntax ifStatement,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (IfElseChain.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);
}
private static IfStatementSyntax GetTopmostIf(BlockSyntax block)
{
SyntaxNode parent = block.Parent;
switch (parent?.Kind())
{
case SyntaxKind.IfStatement:
return(IfElseChain.GetTopmostIf((IfStatementSyntax)parent));
case SyntaxKind.ElseClause:
return(IfElseChain.GetTopmostIf((ElseClauseSyntax)parent));
default:
return(null);
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, StatementSyntax statement)
{
if (!statement.IsKind(SyntaxKind.IfStatement) ||
!IfElseChain.IsPartOfChain((IfStatementSyntax)statement))
{
StatementSyntax embeddedStatement = GetEmbeddedStatementThatShouldBeInsideBlock(statement);
if (embeddedStatement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AddBraces,
embeddedStatement.GetLocation(),
GetName(statement));
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, ElseClauseSyntax elseClause)
{
StatementSyntax statement = elseClause.Statement;
SyntaxToken elseKeyword = elseClause.ElseKeyword;
if (statement?.IsKind(SyntaxKind.Block, SyntaxKind.IfStatement) == false &&
context.SyntaxTree().IsMultiLineSpan(TextSpan.FromBounds(elseKeyword.SpanStart, statement.SpanStart)))
{
IfStatementSyntax topmostIf = IfElseChain.GetTopmostIf(elseClause);
if (topmostIf != null)
{
Analyze(context, topmostIf, elseKeyword, statement);
}
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, IfStatementSyntax ifStatement)
{
if (!IfElseChain.IsPartOfChain(ifStatement) &&
CheckCondition(ifStatement.Condition))
{
IfStatementSyntax nestedIf = GetNestedIfStatement(ifStatement);
if (nestedIf != null &&
nestedIf.Else == null &&
CheckCondition(nestedIf.Condition) &&
CheckTrivia(ifStatement, nestedIf) &&
!ifStatement.SpanContainsDirectives())
{
ReportDiagnostic(context, ifStatement, nestedIf);
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, IfStatementSyntax ifStatement)
{
if (IfElseChain.IsTopmostIf(ifStatement))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (GetIfStatements(ifStatement)
.All(f => IsValidIf(f, semanticModel, context.CancellationToken)))
{
string title = (ifStatement.IsSimpleIf())
? "Replace if with switch"
: "Replace if-else with switch";
context.RegisterRefactoring(
title,
cancellationToken => RefactorAsync(context.Document, ifStatement, cancellationToken));
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IfStatementSyntax ifStatement)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf,
RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf,
RefactoringIdentifiers.SimplifyIf,
RefactoringIdentifiers.SwapStatementsInIfElse,
RefactoringIdentifiers.ReplaceIfElseWithSwitch) &&
IfElseChain.IsTopmostIf(ifStatement) &&
context.Span.IsBetweenSpans(ifStatement))
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf,
RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf,
RefactoringIdentifiers.SimplifyIf))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
var options = new IfAnalysisOptions(
useCoalesceExpression: context.IsRefactoringEnabled(RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf),
useConditionalExpression: context.IsRefactoringEnabled(RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf),
useBooleanExpression: context.IsRefactoringEnabled(RefactoringIdentifiers.SimplifyIf));
foreach (IfRefactoring refactoring in IfRefactoring.Analyze(ifStatement, options, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
refactoring.Title,
cancellationToken => refactoring.RefactorAsync(context.Document, cancellationToken));
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapStatementsInIfElse))
{
SwapStatementInIfElseRefactoring.ComputeRefactoring(context, ifStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfElseWithSwitch))
{
await ReplaceIfElseWithSwitchRefactoring.ComputeRefactoringAsync(context, ifStatement).ConfigureAwait(false);
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
IfStatementSyntax ifStatement = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <IfStatementSyntax>();
if (ifStatement == null)
{
return;
}
ifStatement = IfElseChain.GetTopmostIf(ifStatement);
CodeAction codeAction = CodeAction.Create(
"Remove braces from if-else",
cancellationToken => RemoveBracesFromIfElseElseRefactoring.RefactorAsync(context.Document, ifStatement, cancellationToken),
DiagnosticIdentifiers.RemoveBracesFromIfElse + EquivalenceKeySuffix);
context.RegisterCodeFix(codeAction, context.Diagnostics);
}
private static IfStatementSyntax GetTopmostIf(StatementSyntax statement)
{
SyntaxNode parent = statement.Parent;
if (parent != null)
{
if (parent.IsKind(SyntaxKind.ElseClause))
{
return(IfElseChain.GetTopmostIf((ElseClauseSyntax)parent));
}
else
{
var parentStatement = parent as IfStatementSyntax;
if (parentStatement != null)
{
return(IfElseChain.GetTopmostIf(parentStatement));
}
}
}
return(null);
}
private static IEnumerable <StatementSyntax> GetEmbeddedStatements(IfStatementSyntax topmostIf)
{
foreach (SyntaxNode node in IfElseChain.GetChain(topmostIf))
{
switch (node.Kind())
{
case SyntaxKind.IfStatement:
{
var ifStatement = (IfStatementSyntax)node;
StatementSyntax statement = ifStatement.Statement;
if (statement?.IsKind(SyntaxKind.Block) == false)
{
yield return(statement);
}
break;
}
case SyntaxKind.ElseClause:
{
var elseClause = (ElseClauseSyntax)node;
StatementSyntax statement = elseClause.Statement;
if (statement?.IsKind(SyntaxKind.Block) == false)
{
yield return(statement);
}
break;
}
}
}
}
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.IsParentKind(SyntaxKind.UsingStatement))
{
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 (IfElseChain.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(IfElseChain.GetTopmostIf(elseClause));
}
break;
}
case SyntaxKind.CatchClause:
{
var catchClause = (CatchClauseSyntax)parent;
if (catchClause.IsParentKind(SyntaxKind.TryStatement))
{
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.IsParentKind(SyntaxKind.TryStatement))
{
var tryStatement = (TryStatementSyntax)finallyClause.Parent;
if (finallyClause.Block?.CloseBraceToken.Span.Contains(context.Span) == true)
{
return(tryStatement);
}
}
break;
}
}
return(null);
}
public static void ComputeRefactoring(RefactoringContext context, IfStatementSyntax ifStatement)
{
if (IfElseChain.IsTopmostIf(ifStatement))
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause != null)
{
StatementSyntax statement1 = ReplaceIfWithStatementRefactoring.GetStatement(ifStatement);
if (statement1?.IsKind(SyntaxKind.ExpressionStatement) == true)
{
StatementSyntax statement2 = ReplaceIfWithStatementRefactoring.GetStatement(elseClause);
if (statement2?.IsKind(SyntaxKind.ExpressionStatement) == true)
{
var expressionStatement1 = (ExpressionStatementSyntax)statement1;
var expressionStatement2 = (ExpressionStatementSyntax)statement2;
ExpressionSyntax expression1 = expressionStatement1.Expression;
if (expression1?.IsKind(SyntaxKind.SimpleAssignmentExpression) == true)
{
ExpressionSyntax expression2 = expressionStatement2.Expression;
if (expression2?.IsKind(SyntaxKind.SimpleAssignmentExpression) == true)
{
var assignment1 = (AssignmentExpressionSyntax)expression1;
var assignment2 = (AssignmentExpressionSyntax)expression2;
ExpressionSyntax left1 = assignment1.Left;
ExpressionSyntax right1 = assignment1.Right;
if (left1?.IsMissing == false &&
right1?.IsMissing == false)
{
ExpressionSyntax left2 = assignment2.Left;
ExpressionSyntax right2 = assignment2.Right;
if (left2?.IsMissing == false &&
right2?.IsMissing == false &&
left1.IsEquivalentTo(left2, topLevel: false))
{
context.RegisterRefactoring(
"Replace if-else with assignment",
cancellationToken =>
{
return(RefactorAsync(
context.Document,
ifStatement,
left1,
right1,
right2,
cancellationToken));
});
}
}
}
}
}
}
}
}
}
public static ImmutableArray <IfRefactoring> Analyze(
IfStatementSyntax ifStatement,
IfAnalysisOptions options,
SemanticModel semanticModel,
CancellationToken cancellationToken = default(CancellationToken))
{
if (IfElseChain.IsTopmostIf(ifStatement))
{
ExpressionSyntax condition = ifStatement.Condition;
if (condition != null)
{
ElseClauseSyntax elseClause = ifStatement.Else;
if (elseClause != null)
{
if (options.CheckSpanDirectives(ifStatement))
{
StatementSyntax statement1 = ifStatement.GetSingleStatementOrDefault();
if (statement1 != null)
{
SyntaxKind kind1 = statement1.Kind();
if (kind1 == SyntaxKind.ExpressionStatement ||
kind1 == SyntaxKind.ReturnStatement ||
kind1 == SyntaxKind.YieldReturnStatement)
{
StatementSyntax statement2 = elseClause.GetSingleStatementOrDefault();
if (statement2?.IsKind(kind1) == true)
{
switch (kind1)
{
case SyntaxKind.ExpressionStatement:
{
return(Analyze(ifStatement, condition, (ExpressionStatementSyntax)statement1, (ExpressionStatementSyntax)statement2, options));
}
case SyntaxKind.ReturnStatement:
{
return(Analyze(ifStatement, condition, ((ReturnStatementSyntax)statement1).Expression, ((ReturnStatementSyntax)statement2).Expression, semanticModel, cancellationToken, options, isYield: false));
}
case SyntaxKind.YieldReturnStatement:
{
return(Analyze(ifStatement, condition, ((YieldStatementSyntax)statement1).Expression, ((YieldStatementSyntax)statement2).Expression, semanticModel, cancellationToken, options, isYield: true));
}
}
}
}
}
}
}
else
{
StatementSyntax nextStatement = ifStatement.NextStatement();
if (nextStatement?.IsKind(SyntaxKind.ReturnStatement) == true)
{
return(Analyze(ifStatement, (ReturnStatementSyntax)nextStatement, options, semanticModel, cancellationToken));
}
}
}
}
return(ImmutableArray <IfRefactoring> .Empty);
}
public static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
var ifStatement = (IfStatementSyntax)context.Node;
if (!IfElseChain.IsPartOfChain(ifStatement))
{
ExpressionSyntax condition = ifStatement.Condition;
if (condition?.IsKind(SyntaxKind.EqualsExpression) == true)
{
var equalsExpression = (BinaryExpressionSyntax)condition;
ExpressionSyntax left = equalsExpression.Left;
if (left != null)
{
ExpressionSyntax right = equalsExpression.Right;
if (right?.IsKind(SyntaxKind.NullLiteralExpression) == true)
{
StatementSyntax blockOrStatement = ifStatement.Statement;
StatementSyntax childStatement = GetSingleStatementOrDefault(blockOrStatement);
if (childStatement?.IsKind(SyntaxKind.ExpressionStatement) == true)
{
var expressionStatement = (ExpressionStatementSyntax)childStatement;
ExpressionSyntax expression = expressionStatement.Expression;
if (expression?.IsKind(SyntaxKind.SimpleAssignmentExpression) == true)
{
var assignment = (AssignmentExpressionSyntax)expression;
if (assignment.Left?.IsEquivalentTo(left, topLevel: false) == true &&
assignment.Right?.IsMissing == false &&
!ifStatement.SpanContainsDirectives())
{
StatementSyntax statementToReport = ifStatement;
SyntaxNode parent = ifStatement.Parent;
SyntaxList <StatementSyntax> statements = GetStatements(parent);
if (statements.Any())
{
int index = statements.IndexOf(ifStatement);
if (index > 0)
{
StatementSyntax previousStatement = statements[index - 1];
if (CanRefactor(previousStatement, ifStatement, left, parent))
{
statementToReport = previousStatement;
}
}
}
context.ReportDiagnostic(DiagnosticDescriptors.UseCoalesceExpression, statementToReport);
}
}
}
}
}
}
}
}
