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);
}
}
}
public static async Task ComputeRefactoringAsync(RefactoringContext context, SelectedStatementsInfo info)
{
if (info.IsAnySelected)
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInUsingStatement) &&
context.SupportsSemanticModel)
{
var refactoring = new WrapInUsingStatementRefactoring();
await refactoring.ComputeRefactoringAsync(context, info).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CollapseToInitializer))
{
await CollapseToInitializerRefactoring.ComputeRefactoringsAsync(context, info).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeIfStatements))
{
MergeIfStatementsRefactoring.ComputeRefactorings(context, info);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.ReplaceIfElseWithSwitch))
{
ReplaceIfElseWithSwitchRefactoring.ComputeRefactoring(context, info);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeLocalDeclarations) &&
context.SupportsSemanticModel)
{
await MergeLocalDeclarationsRefactoring.ComputeRefactoringsAsync(context, info).ConfigureAwait(false);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.MergeAssignmentExpressionWithReturnStatement))
{
MergeAssignmentExpressionWithReturnStatementRefactoring.ComputeRefactorings(context, info);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInCondition))
{
context.RegisterRefactoring(
"Wrap in condition",
cancellationToken =>
{
var refactoring = new WrapInIfStatementRefactoring();
return(refactoring.RefactorAsync(context.Document, info, cancellationToken));
});
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.WrapInTryCatch))
{
context.RegisterRefactoring(
"Wrap in try-catch",
cancellationToken =>
{
var refactoring = new WrapInTryCatchRefactoring();
return(refactoring.RefactorAsync(context.Document, info, 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));
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);
}
}
}
