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));
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);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitIfStatement))
{
SplitIfStatementRefactoring.ComputeRefactoring(context, ifStatement);
}
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReduceIfNesting) &&
context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(ifStatement.IfKeyword))
{
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
if (ReduceIfNestingRefactoring.IsFixable(
ifStatement,
semanticModel,
semanticModel.GetTypeByMetadataName(MetadataNames.System_Threading_Tasks_Task),
context.CancellationToken,
topLevelOnly: false))
{
context.RegisterRefactoring(
"Reduce if nesting",
cancellationToken => ReduceIfNestingRefactoring.RefactorAsync(context.Document, ifStatement, context.CancellationToken));
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, IfStatementSyntax ifStatement)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf,
RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf,
RefactoringIdentifiers.SimplifyIf,
RefactoringIdentifiers.SwapStatementsInIfElse,
RefactoringIdentifiers.ReplaceIfElseWithSwitch) &&
ifStatement.IsTopmostIf() &&
context.Span.IsBetweenSpans(ifStatement))
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.UseCoalesceExpressionInsteadOfIf,
RefactoringIdentifiers.UseConditionalExpressionInsteadOfIf,
RefactoringIdentifiers.SimplifyIf,
RefactoringIdentifiers.SplitIfStatement))
{
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);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.SplitIfStatement))
{
SplitIfStatementRefactoring.ComputeRefactoring(context, ifStatement);
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, SelectedStatementCollection selectedStatements)
{
if (selectedStatements.Any())
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInUsingStatement))
{
var refactoring = new 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));
foreach (IfRefactoring refactoring in IfRefactoring.Analyze(selectedStatements, options, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
refactoring.Title,
cancellationToken => refactoring.RefactorAsync(context.Document, 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.WrapInCondition))
{
context.RegisterRefactoring(
"Wrap in condition",
cancellationToken =>
{
var refactoring = new WrapInIfStatementRefactoring();
return(refactoring.RefactorAsync(context.Document, selectedStatements, cancellationToken));
});
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInTryCatch))
{
context.RegisterRefactoring(
"Wrap in try-catch",
cancellationToken =>
{
var refactoring = new WrapInTryCatchRefactoring();
return(refactoring.RefactorAsync(context.Document, selectedStatements, cancellationToken));
});
}
}
}
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 (IfRefactoring refactoring in IfRefactoring.Analyze(ifStatement, options, semanticModel, context.CancellationToken))
{
context.RegisterRefactoring(
refactoring.Title,
cancellationToken => refactoring.RefactorAsync(context.Document, 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);
ReduceIfNestingAnalysis analysis = ReduceIfNestingRefactoring.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 (ReduceIfNestingRefactoring.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);
}
}
