public static async Task <Document> RefactorAsync(
Document document,
SwitchStatementSyntax switchStatement,
SwitchSectionSyntax[] sections,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
IEnumerable <SwitchSectionSyntax> newSections = switchStatement
.Sections
.Select(section =>
{
if ((sections == null || Array.IndexOf(sections, section) != -1) &&
SwitchStatementAnalysis.CanAddBraces(section))
{
return(section.WithStatements(SingletonList <StatementSyntax>(Block(section.Statements))));
}
else
{
return(section);
}
});
SwitchStatementSyntax newSwitchStatement = switchStatement
.WithSections(List(newSections))
.WithFormatterAnnotation();
SyntaxNode newRoot = root.ReplaceNode(switchStatement, newSwitchStatement);
return(document.WithSyntaxRoot(newRoot));
}
private static async Task <Document> RemoveBracesFromSwitchSectionsAsync(
Document document,
SwitchStatementSyntax switchStatement,
CancellationToken cancellationToken)
{
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
IEnumerable <SwitchSectionSyntax> newSections = switchStatement
.Sections
.Select(section =>
{
if (SwitchStatementAnalysis.CanRemoveBracesFromSection(section))
{
var block = (BlockSyntax)section.Statements[0];
return(section.WithStatements(block.Statements));
}
else
{
return(section);
}
});
SwitchStatementSyntax newSwitchStatement = switchStatement
.WithSections(List(newSections))
.WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode newRoot = oldRoot.ReplaceNode(switchStatement, newSwitchStatement);
return(document.WithSyntaxRoot(newRoot));
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
SwitchStatementSyntax switchStatement = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <SwitchStatementSyntax>();
if (switchStatement == null)
{
return;
}
if (switchStatement.Sections.Count > 0 &&
switchStatement.SwitchKeyword.Span.Contains(context.Span))
{
SwitchStatementAnalysisResult result = SwitchStatementAnalysis.Analyze(switchStatement);
if (result.CanAddBraces)
{
context.RegisterRefactoring(
"Add braces to switch sections",
cancellationToken => AddBracesToSwitchSectionsAsync(context.Document, switchStatement, cancellationToken));
}
if (result.CanRemoveBraces)
{
context.RegisterRefactoring(
"Remove braces from switch sections",
cancellationToken => RemoveBracesFromSwitchSectionsAsync(context.Document, switchStatement, cancellationToken));
}
if (switchStatement.Sections
.Any(section => !section.Labels.Contains(SyntaxKind.DefaultSwitchLabel)))
{
context.RegisterRefactoring(
"Convert to if-else chain",
cancellationToken => ConvertSwitchToIfElseRefactoring.RefactorAsync(context.Document, switchStatement, cancellationToken));
}
}
}
public static void ComputeRefactorings(RefactoringContext context, SwitchStatementSyntax switchStatement)
{
bool fRemoveStatements = context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveStatementsFromSwitchSections);
bool fAddBraces = context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSections);
bool fRemoveBraces = context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSections);
if (fRemoveStatements || fAddBraces || fRemoveBraces)
{
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
if (sections.Any())
{
var info = new SelectedNodesInfo <SwitchSectionSyntax>(sections, context.Span);
if (info.IsAnySelected)
{
if (fAddBraces || fRemoveBraces)
{
var addBraces = new List <SwitchSectionSyntax>();
var removeBraces = new List <SwitchSectionSyntax>();
foreach (SwitchSectionSyntax section in info.SelectedNodes())
{
if (addBraces.Count > 0 &&
removeBraces.Count > 0)
{
break;
}
switch (SwitchStatementAnalysis.AnalyzeSection(section))
{
case SwitchSectionAnalysisResult.AddBraces:
{
addBraces.Add(section);
break;
}
case SwitchSectionAnalysisResult.RemoveBraces:
{
removeBraces.Add(section);
break;
}
}
}
if (fAddBraces && addBraces.Count > 0)
{
string title = AddBracesToSwitchSectionRefactoring.Title;
if (addBraces.Count > 1)
{
title += "s";
}
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(AddBracesToSwitchSectionsRefactoring.RefactorAsync(
context.Document,
switchStatement,
addBraces.ToArray(),
cancellationToken));
});
}
if (fRemoveBraces && removeBraces.Count > 0)
{
string title = RemoveBracesFromSwitchSectionRefactoring.Title;
if (removeBraces.Count > 1)
{
title += "s";
}
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(RemoveBracesFromSwitchSectionsRefactoring.RefactorAsync(
context.Document,
switchStatement,
removeBraces.ToArray(),
cancellationToken));
});
}
}
if (fRemoveStatements)
{
string title = "Remove statements from section";
if (info.AreManySelected)
{
title += "s";
}
context.RegisterRefactoring(
title,
cancellationToken =>
{
return(RemoveStatementsFromSwitchSectionsRefactoring.RefactorAsync(
context.Document,
switchStatement,
info.SelectedNodes().ToImmutableArray(),
cancellationToken));
});
}
}
}
}
}
public static async Task ComputeRefactoringsAsync(RefactoringContext context, SwitchSectionSyntax switchSection)
{
if (SelectedStatementsRefactoring.IsAnyRefactoringEnabled(context))
{
SelectedStatementsInfo info = SelectedStatementsInfo.Create(switchSection, context.Span);
await SelectedStatementsRefactoring.ComputeRefactoringAsync(context, info).ConfigureAwait(false);
}
if (context.Span.IsEmpty &&
context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.AddBracesToSwitchSection,
RefactoringIdentifiers.AddBracesToSwitchSections,
RefactoringIdentifiers.RemoveBracesFromSwitchSection,
RefactoringIdentifiers.RemoveBracesFromSwitchSections))
{
var switchStatement = (SwitchStatementSyntax)switchSection.Parent;
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
switch (SwitchStatementAnalysis.AnalyzeSection(switchSection))
{
case SwitchSectionAnalysisResult.AddBraces:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSection))
{
context.RegisterRefactoring(
AddBracesToSwitchSectionRefactoring.Title,
cancellationToken => AddBracesToSwitchSectionRefactoring.RefactorAsync(context.Document, switchSection, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.AddBracesToSwitchSections) &&
sections.Any(f => f != switchSection && SwitchStatementAnalysis.CanAddBraces(f)))
{
context.RegisterRefactoring(
AddBracesToSwitchSectionsRefactoring.Title,
cancellationToken => AddBracesToSwitchSectionsRefactoring.RefactorAsync(context.Document, switchStatement, null, cancellationToken));
}
break;
}
case SwitchSectionAnalysisResult.RemoveBraces:
{
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSection))
{
context.RegisterRefactoring(
RemoveBracesFromSwitchSectionRefactoring.Title,
cancellationToken => RemoveBracesFromSwitchSectionRefactoring.RefactorAsync(context.Document, switchSection, cancellationToken));
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.RemoveBracesFromSwitchSections) &&
sections.Any(f => f != switchSection && SwitchStatementAnalysis.CanRemoveBraces(f)))
{
context.RegisterRefactoring(
RemoveBracesFromSwitchSectionsRefactoring.Title,
cancellationToken => RemoveBracesFromSwitchSectionsRefactoring.RefactorAsync(context.Document, switchStatement, null, cancellationToken));
}
break;
}
}
}
}
