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)
            {
                return;
            }

            if (!SyntaxListSelection <SwitchSectionSyntax> .TryCreate(switchStatement.Sections, context.Span, out SyntaxListSelection <SwitchSectionSyntax> selectedSections))
            {
                return;
            }

            if (fAddBraces || fRemoveBraces)
            {
                var addBraces    = new List <SwitchSectionSyntax>();
                var removeBraces = new List <SwitchSectionSyntax>();

                foreach (SwitchSectionSyntax section in selectedSections)
                {
                    if (addBraces.Count > 0 &&
                        removeBraces.Count > 0)
                    {
                        break;
                    }

                    BracesAnalysis analysis = BracesAnalysis.AnalyzeBraces(section);

                    if (analysis.AddBraces)
                    {
                        addBraces.Add(section);
                    }
                    else if (analysis.RemoveBraces)
                    {
                        removeBraces.Add(section);
                    }
                }

                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));
                    },
                        RefactoringIdentifiers.AddBracesToSwitchSections);
                }

                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));
                    },
                        RefactoringIdentifiers.RemoveBracesFromSwitchSections);
                }
            }

            if (fRemoveStatements)
            {
                string title = "Remove statements from section";

                if (selectedSections.Count > 1)
                {
                    title += "s";
                }

                context.RegisterRefactoring(
                    title,
                    cancellationToken =>
                {
                    return(RemoveStatementsFromSwitchSectionsRefactoring.RefactorAsync(
                               context.Document,
                               switchStatement,
                               selectedSections.ToImmutableArray(),
                               cancellationToken));
                },
                    RefactoringIdentifiers.RemoveStatementsFromSwitchSections);
            }
        }
        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 selectedSections = new SelectedNodeCollection <SwitchSectionSyntax>(sections, context.Span);

                    if (selectedSections.Any())
                    {
                        if (fAddBraces || fRemoveBraces)
                        {
                            var addBraces    = new List <SwitchSectionSyntax>();
                            var removeBraces = new List <SwitchSectionSyntax>();

                            foreach (SwitchSectionSyntax section in selectedSections)
                            {
                                if (addBraces.Count > 0 &&
                                    removeBraces.Count > 0)
                                {
                                    break;
                                }

                                switch (CSharpAnalysis.AnalyzeBraces(section))
                                {
                                case BracesAnalysisResult.AddBraces:
                                {
                                    addBraces.Add(section);
                                    break;
                                }

                                case BracesAnalysisResult.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 (selectedSections.IsMultiple)
                            {
                                title += "s";
                            }

                            context.RegisterRefactoring(
                                title,
                                cancellationToken =>
                            {
                                return(RemoveStatementsFromSwitchSectionsRefactoring.RefactorAsync(
                                           context.Document,
                                           switchStatement,
                                           selectedSections.ToImmutableArray(),
                                           cancellationToken));
                            });
                        }
                    }
                }
            }
        }