internal static string GetRefactoringIdentifier(IfAnalysis analysis)
{
switch (analysis.Kind)
{
case IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression:
case IfAnalysisKind.IfElseToReturnWithCoalesceExpression:
case IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression:
case IfAnalysisKind.IfReturnToReturnWithCoalesceExpression:
return(RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf);
case IfAnalysisKind.IfElseToAssignmentWithConditionalExpression:
case IfAnalysisKind.AssignmentAndIfElseToAssignmentWithConditionalExpression:
case IfAnalysisKind.LocalDeclarationAndIfElseAssignmentWithConditionalExpression:
case IfAnalysisKind.IfElseToReturnWithConditionalExpression:
case IfAnalysisKind.IfElseToYieldReturnWithConditionalExpression:
case IfAnalysisKind.IfReturnToReturnWithConditionalExpression:
return(RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf);
case IfAnalysisKind.IfElseToReturnWithBooleanExpression:
case IfAnalysisKind.IfElseToYieldReturnWithBooleanExpression:
case IfAnalysisKind.IfReturnToReturnWithBooleanExpression:
return(RefactoringIdentifiers.SimplifyIf);
case IfAnalysisKind.IfElseToAssignmentWithExpression:
case IfAnalysisKind.IfElseToAssignmentWithCondition:
case IfAnalysisKind.IfElseToReturnWithExpression:
case IfAnalysisKind.IfElseToYieldReturnWithExpression:
case IfAnalysisKind.IfReturnToReturnWithExpression:
return(null);
}
Debug.Fail(analysis.Kind.ToString());
return(null);
}
private static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
var ifStatement = (IfStatementSyntax)context.Node;
foreach (IfAnalysis analysis in IfAnalysis.Analyze(ifStatement, AnalysisOptions, context.SemanticModel, context.CancellationToken))
{
Debug.Assert(
analysis.Kind == IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression ||
analysis.Kind == IfAnalysisKind.IfElseToAssignmentWithExpression ||
analysis.Kind == IfAnalysisKind.IfElseToAssignmentWithCondition ||
analysis.Kind == IfAnalysisKind.IfElseToReturnWithCoalesceExpression ||
analysis.Kind == IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression ||
analysis.Kind == IfAnalysisKind.IfReturnToReturnWithCoalesceExpression ||
analysis.Kind == IfAnalysisKind.IfElseToReturnWithExpression ||
analysis.Kind == IfAnalysisKind.IfElseToYieldReturnWithExpression ||
analysis.Kind == IfAnalysisKind.IfReturnToReturnWithExpression,
analysis.Kind.ToString());
switch (analysis.Kind)
{
case IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression:
case IfAnalysisKind.IfElseToReturnWithCoalesceExpression:
case IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression:
case IfAnalysisKind.IfReturnToReturnWithCoalesceExpression:
{
if (!context.IsAnalyzerSuppressed(DiagnosticDescriptors.UseCoalesceExpressionInsteadOfIf))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.UseCoalesceExpressionInsteadOfIf, ifStatement);
}
break;
}
case IfAnalysisKind.IfElseToReturnWithExpression:
case IfAnalysisKind.IfElseToYieldReturnWithExpression:
case IfAnalysisKind.IfReturnToReturnWithExpression:
{
if (!context.IsAnalyzerSuppressed(DiagnosticDescriptors.ConvertIfToReturnStatement))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.ConvertIfToReturnStatement, ifStatement);
}
break;
}
case IfAnalysisKind.IfElseToAssignmentWithExpression:
case IfAnalysisKind.IfElseToAssignmentWithCondition:
{
if (!context.IsAnalyzerSuppressed(DiagnosticDescriptors.ConvertIfToAssignment))
{
DiagnosticHelpers.ReportDiagnostic(context, DiagnosticDescriptors.ConvertIfToAssignment, ifStatement);
}
break;
}
}
}
}
private static void AnalyzeIfStatement(SyntaxNodeAnalysisContext context)
{
var ifStatement = (IfStatementSyntax)context.Node;
foreach (IfAnalysis refactoring in IfAnalysis.Analyze(ifStatement, AnalysisOptions, context.SemanticModel, context.CancellationToken))
{
Debug.Assert(refactoring.Kind == IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression ||
refactoring.Kind == IfAnalysisKind.IfElseToAssignmentWithExpression ||
refactoring.Kind == IfAnalysisKind.IfElseToAssignmentWithCondition ||
refactoring.Kind == IfAnalysisKind.IfElseToReturnWithCoalesceExpression ||
refactoring.Kind == IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression ||
refactoring.Kind == IfAnalysisKind.IfReturnToReturnWithCoalesceExpression ||
refactoring.Kind == IfAnalysisKind.IfElseToReturnWithExpression ||
refactoring.Kind == IfAnalysisKind.IfElseToYieldReturnWithExpression ||
refactoring.Kind == IfAnalysisKind.IfReturnToReturnWithExpression, refactoring.Kind.ToString());
switch (refactoring.Kind)
{
case IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression:
case IfAnalysisKind.IfElseToReturnWithCoalesceExpression:
case IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression:
case IfAnalysisKind.IfReturnToReturnWithCoalesceExpression:
{
context.ReportDiagnostic(DiagnosticDescriptors.UseCoalesceExpressionInsteadOfIf, ifStatement);
break;
}
case IfAnalysisKind.IfElseToReturnWithExpression:
case IfAnalysisKind.IfElseToYieldReturnWithExpression:
case IfAnalysisKind.IfReturnToReturnWithExpression:
{
context.ReportDiagnostic(DiagnosticDescriptors.ReplaceIfStatementWithReturnStatement, ifStatement);
break;
}
case IfAnalysisKind.IfElseToAssignmentWithExpression:
case IfAnalysisKind.IfElseToAssignmentWithCondition:
{
context.ReportDiagnostic(DiagnosticDescriptors.ReplaceIfStatementWithAssignment, ifStatement);
break;
}
}
}
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindFirstAncestorOrSelf(root, context.Span, out IfStatementSyntax ifStatement))
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case DiagnosticIdentifiers.MergeIfWithNestedIf:
{
CodeAction codeAction = CodeAction.Create(
"Merge 'if' with nested 'if'",
ct => MergeIfWithNestedIfAsync(context.Document, ifStatement, ct),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseCoalesceExpressionInsteadOfIf:
case DiagnosticIdentifiers.ConvertIfToReturnStatement:
case DiagnosticIdentifiers.ConvertIfToAssignment:
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IfAnalysis analysis = IfAnalysis.Analyze(
ifStatement,
IfStatementAnalyzer.AnalysisOptions,
semanticModel,
context.CancellationToken)
.First();
CodeAction codeAction = CodeAction.Create(
analysis.Title,
cancellationToken => IfRefactoring.RefactorAsync(context.Document, analysis, cancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.ReduceIfNesting:
{
CodeAction codeAction = CodeAction.Create(
"Invert if",
cancellationToken =>
{
return(ReduceIfNestingRefactoring.RefactorAsync(
context.Document,
ifStatement,
(SyntaxKind)Enum.Parse(typeof(SyntaxKind), diagnostic.Properties["JumpKind"]),
recursive: true,
cancellationToken: cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
case DiagnosticIdentifiers.UseExceptionFilter:
{
CodeAction codeAction = CodeAction.Create(
"Use exception filter",
cancellationToken =>
{
return(UseExceptionFilterAsync(
context.Document,
ifStatement,
cancellationToken: cancellationToken));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, StatementListSelection selectedStatements)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInUsingStatement))
{
var refactoring = new WrapStatements.WrapInUsingStatementRefactoring();
await refactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CollapseToInitializer))
{
await CollapseToInitializerRefactoring.ComputeRefactoringsAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeIfStatements))
{
MergeIfStatementsRefactoring.ComputeRefactorings(context, selectedStatements);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertStatementsToIfElse))
{
ConvertStatementsToIfElseRefactoring.ComputeRefactorings(context, selectedStatements);
}
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf,
RefactoringIdentifiers.ConvertIfToConditionalOperator,
RefactoringIdentifiers.SimplifyIf))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IfAnalysisOptions options = IfStatementRefactoring.GetIfAnalysisOptions(context);
foreach (IfAnalysis analysis in IfAnalysis.Analyze(selectedStatements, options, semanticModel, context.CancellationToken))
{
string refactoringId = IfStatementRefactoring.GetRefactoringIdentifier(analysis);
if (context.IsRefactoringEnabled(refactoringId))
{
context.RegisterRefactoring(
analysis.Title,
cancellationToken => IfRefactoring.RefactorAsync(context.Document, analysis, cancellationToken),
equivalenceKey: refactoringId);
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeLocalDeclarations))
{
await MergeLocalDeclarationsRefactoring.ComputeRefactoringsAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeAssignmentExpressionWithReturnStatement))
{
MergeAssignmentExpressionWithReturnStatementRefactoring.ComputeRefactorings(context, selectedStatements);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CheckExpressionForNull))
{
await CheckExpressionForNullRefactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ConvertWhileToFor))
{
await ConvertWhileToForRefactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInCondition))
{
context.RegisterRefactoring(
WrapInIfStatementRefactoring.Title,
ct => WrapInIfStatementRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct),
RefactoringIdentifiers.WrapInCondition);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInTryCatch))
{
context.RegisterRefactoring(
WrapInTryCatchRefactoring.Title,
ct => WrapInTryCatchRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct),
RefactoringIdentifiers.WrapInTryCatch);
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IfStatementSyntax ifStatement)
{
SyntaxToken ifKeyword = ifStatement.IfKeyword;
bool isTopmostIf = ifStatement.IsTopmostIf();
if (context.Span.IsEmptyAndContainedInSpan(ifKeyword) ||
context.Span.IsBetweenSpans(ifStatement))
{
if (isTopmostIf &&
context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf,
RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf,
RefactoringIdentifiers.SimplifyIf))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IfAnalysisOptions options = GetIfAnalysisOptions(context);
foreach (IfAnalysis analysis in IfAnalysis.Analyze(ifStatement, options, semanticModel, context.CancellationToken))
{
string refactoringId = GetRefactoringIdentifier(analysis);
if (context.IsRefactoringEnabled(refactoringId))
{
context.RegisterRefactoring(
analysis.Title,
ct => IfRefactoring.RefactorAsync(context.Document, analysis, ct),
refactoringId);
}
}
}
if (context.IsAnyRefactoringEnabled(RefactoringIdentifiers.InvertIf, RefactoringIdentifiers.InvertIfElse) &&
isTopmostIf &&
context.Span.IsEmptyAndContainedInSpan(ifKeyword))
{
InvertIfRefactoring.ComputeRefactoring(context, ifStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfWithSwitch) &&
isTopmostIf)
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ReplaceIfWithSwitchRefactoring.ComputeRefactoring(context, ifStatement, semanticModel);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitIfStatement))
{
SplitIfStatementRefactoring.ComputeRefactoring(context, ifStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeIfWithParentIf) &&
isTopmostIf &&
context.Span.IsEmptyAndContainedInSpan(ifKeyword))
{
MergeIfWithParentIfRefactoring.ComputeRefactoring(context, ifStatement);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.InvertIf) &&
context.Span.IsEmptyAndContainedInSpan(ifKeyword))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ReduceIfNestingAnalysisResult analysis = ReduceIfNestingAnalysis.Analyze(
ifStatement,
semanticModel,
options: ReduceIfNestingOptions.AllowNestedFix
| ReduceIfNestingOptions.AllowIfInsideIfElse
| ReduceIfNestingOptions.AllowLoop
| ReduceIfNestingOptions.AllowSwitchSection,
cancellationToken: context.CancellationToken);
if (analysis.Success)
{
context.RegisterRefactoring(
"Invert if",
ct => ReduceIfNestingRefactoring.RefactorAsync(context.Document, ifStatement, analysis.JumpKind, false, ct),
RefactoringIdentifiers.InvertIf);
if (ReduceIfNestingAnalysis.IsFixableRecursively(ifStatement, analysis.JumpKind))
{
context.RegisterRefactoring(
"Invert if (recursively)",
ct => ReduceIfNestingRefactoring.RefactorAsync(context.Document, ifStatement, analysis.JumpKind, true, ct),
EquivalenceKey.Join(RefactoringIdentifiers.InvertIf, "Recursive"));
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitIfElse) &&
context.Span.IsEmptyAndContainedInSpan(ifKeyword))
{
SplitIfElseRefactoring.ComputeRefactoring(context, ifStatement);
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, StatementListSelection selectedStatements)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInUsingStatement))
{
var refactoring = new WrapStatements.WrapInUsingStatementRefactoring();
await refactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CollapseToInitializer))
{
await CollapseToInitializerRefactoring.ComputeRefactoringsAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeIfStatements))
{
MergeIfStatementsRefactoring.ComputeRefactorings(context, selectedStatements);
}
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),
useExpression: false);
foreach (IfAnalysis analysis in IfAnalysis.Analyze(selectedStatements, options, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
analysis.Title,
cancellationToken => IfRefactoring.RefactorAsync(context.Document, analysis, cancellationToken));
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeLocalDeclarations))
{
await MergeLocalDeclarationsRefactoring.ComputeRefactoringsAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeAssignmentExpressionWithReturnStatement))
{
MergeAssignmentExpressionWithReturnStatementRefactoring.ComputeRefactorings(context, selectedStatements);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CheckExpressionForNull))
{
await CheckExpressionForNullRefactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceWhileWithFor))
{
await ReplaceWhileWithForRefactoring.ComputeRefactoringAsync(context, selectedStatements).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInElseClause))
{
WrapInElseClauseRefactoring.ComputeRefactoring(context, selectedStatements);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInCondition))
{
context.RegisterRefactoring(
WrapInIfStatementRefactoring.Title,
ct => WrapInIfStatementRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInTryCatch))
{
context.RegisterRefactoring(
WrapInTryCatchRefactoring.Title,
ct => WrapInTryCatchRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct));
}
}
public static Task <Document> RefactorAsync(Document document, IfAnalysis ifAnalysis, CancellationToken cancellationToken = default)
{
switch (ifAnalysis.Kind)
{
case IfAnalysisKind.IfElseToAssignmentWithCoalesceExpression:
{
return(IfElseToAssignmentWithCoalesceExpressionAsync(document, (IfElseToAssignmentWithCoalesceExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToAssignmentWithConditionalExpression:
{
return(IfElseToAssignmentWithConditionalExpressionAsync(document, (IfElseToAssignmentWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.AssignmentAndIfToAssignmentWithConditionalExpression:
{
var analysis = (AssignmentAndIfToAssignmentWithConditionalExpressionAnalysis)ifAnalysis;
ConditionalExpressionSyntax conditionalExpression = CreateConditionalExpression(analysis.IfStatement.Condition, analysis.WhenTrue, analysis.WhenFalse);
ExpressionStatementSyntax newStatement = analysis.Statement.ReplaceNode(analysis.Right, conditionalExpression);
return(ToAssignmentWithConditionalExpressionAsync(document, analysis, newStatement, cancellationToken));
}
case IfAnalysisKind.LocalDeclarationAndIfElseAssignmentWithConditionalExpression:
{
var analysis = (LocalDeclarationAndIfElseToAssignmentWithConditionalExpressionAnalysis)ifAnalysis;
ConditionalExpressionSyntax conditionalExpression = CreateConditionalExpression(analysis.IfStatement.Condition, analysis.WhenTrue, analysis.WhenFalse);
VariableDeclaratorSyntax declarator = analysis.Statement.Declaration.Variables[0];
EqualsValueClauseSyntax initializer = declarator.Initializer;
EqualsValueClauseSyntax newInitializer = (initializer != null)
? initializer.WithValue(conditionalExpression)
: EqualsValueClause(conditionalExpression);
LocalDeclarationStatementSyntax newStatement = analysis.Statement.ReplaceNode(declarator, declarator.WithInitializer(newInitializer));
return(ToAssignmentWithConditionalExpressionAsync(document, analysis, newStatement, cancellationToken));
}
case IfAnalysisKind.IfElseToAssignmentWithExpression:
{
return(IfElseToAssignmentWithExpressionAsync(document, (IfElseToAssignmentWithExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToAssignmentWithCondition:
{
return(IfElseToAssignmentWithConditionAsync(document, (IfElseToAssignmentWithConditionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToReturnWithCoalesceExpression:
case IfAnalysisKind.IfElseToYieldReturnWithCoalesceExpression:
case IfAnalysisKind.IfReturnToReturnWithCoalesceExpression:
{
return(IfToReturnWithCoalesceExpressionAsync(document, (IfToReturnWithCoalesceExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToReturnWithConditionalExpression:
{
return(IfElseToReturnWithConditionalExpressionAsync(document, (IfElseToReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToReturnWithBooleanExpression:
{
return(IfElseToReturnWithBooleanExpressionAsync(document, (IfElseToReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToReturnWithExpression:
case IfAnalysisKind.IfElseToYieldReturnWithExpression:
case IfAnalysisKind.IfReturnToReturnWithExpression:
{
return(IfToReturnWithExpressionAsync(document, (IfToReturnWithExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToYieldReturnWithConditionalExpression:
{
return(IfElseToYieldReturnWithConditionalExpressionAsync(document, (IfElseToYieldReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfElseToYieldReturnWithBooleanExpression:
{
return(IfElseToYieldReturnWithBooleanExpressionAsync(document, (IfElseToYieldReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfReturnToReturnWithConditionalExpression:
{
return(IfReturnToReturnWithConditionalExpressionAsync(document, (IfReturnToReturnWithConditionalExpressionAnalysis)ifAnalysis, cancellationToken));
}
case IfAnalysisKind.IfReturnToReturnWithBooleanExpression:
{
return(IfReturnToReturnWithBooleanExpressionAsync(document, (IfReturnToReturnWithBooleanExpressionAnalysis)ifAnalysis, cancellationToken));
}
default:
{
throw new InvalidOperationException();
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IfStatementSyntax ifStatement)
{
if (ifStatement.IsTopmostIf() &&
(context.Span.IsEmptyAndContainedInSpan(ifStatement.IfKeyword) || 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),
useExpression: false);
foreach (IfAnalysis analysis in IfAnalysis.Analyze(ifStatement, options, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
analysis.Title,
cancellationToken => IfRefactoring.RefactorAsync(context.Document, analysis, cancellationToken));
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SwapIfElse))
{
SwapIfElseRefactoring.ComputeRefactoring(context, ifStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfWithSwitch))
{
await ReplaceIfWithSwitchRefactoring.ComputeRefactoringAsync(context, ifStatement).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitIfStatement))
{
SplitIfStatementRefactoring.ComputeRefactoring(context, ifStatement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeIfWithParentIf) &&
context.Span.IsEmptyAndContainedInSpan(ifStatement.IfKeyword))
{
MergeIfWithParentIfRefactoring.ComputeRefactoring(context, ifStatement);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReduceIfNesting) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(ifStatement.IfKeyword))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
ReduceIfNestingAnalysisResult analysis = ReduceIfNestingAnalysis.Analyze(
ifStatement,
semanticModel,
options: ReduceIfNestingOptions.AllowNestedFix
| ReduceIfNestingOptions.AllowIfInsideIfElse
| ReduceIfNestingOptions.AllowLoop
| ReduceIfNestingOptions.AllowSwitchSection,
taskSymbol: semanticModel.GetTypeByMetadataName(MetadataNames.System_Threading_Tasks_Task),
cancellationToken: context.CancellationToken);
if (analysis.Success)
{
context.RegisterRefactoring(
"Reduce if nesting",
cancellationToken => ReduceIfNestingRefactoring.RefactorAsync(context.Document, ifStatement, analysis.JumpKind, false, cancellationToken));
if (ReduceIfNestingAnalysis.IsFixableRecursively(ifStatement, analysis.JumpKind))
{
context.RegisterRefactoring(
"Reduce if nesting (recursively)",
cancellationToken => ReduceIfNestingRefactoring.RefactorAsync(context.Document, ifStatement, analysis.JumpKind, true, cancellationToken));
}
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitIfElse) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(ifStatement.IfKeyword))
{
SplitIfElseRefactoring.ComputeRefactoring(context, ifStatement);
}
}