public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
        {
            var document = context.Document;

            if (document.Project.Solution.Workspace.Kind == WorkspaceKind.MiscellaneousFiles)
            {
                return;
            }
            var span = context.Span;

            if (!span.IsEmpty)
            {
                return;
            }
            var cancellationToken = context.CancellationToken;

            if (cancellationToken.IsCancellationRequested)
            {
                return;
            }
            var model = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            if (model.IsFromGeneratedCode(cancellationToken))
            {
                return;
            }
            var root = await model.SyntaxTree.GetRootAsync(cancellationToken).ConfigureAwait(false);

            var token = root.FindToken(span.Start);

            if (!token.IsIdentifierOrAccessorOrAccessibilityModifier())
            {
                return;
            }
            var node = token.Parent;

            while (node != null && !(node is MemberDeclarationSyntax || node is AccessorDeclarationSyntax))
            {
                node = node.Parent;
            }
            if (node == null || node.IsKind(SyntaxKind.InterfaceDeclaration, SyntaxKind.EnumMemberDeclaration))
            {
                return;
            }

            ISymbol symbol = null;
            var     field  = node as FieldDeclarationSyntax;

            if (field != null)
            {
                symbol = model.GetDeclaredSymbol(field.Declaration.Variables.First(), cancellationToken);
            }
            else
            {
                var member = node as MemberDeclarationSyntax;
                if (member != null)
                {
                    symbol = model.GetDeclaredSymbol(member, cancellationToken);
                }
                else
                {
                    var accessor = node as AccessorDeclarationSyntax;
                    if (accessor != null)
                    {
                        symbol = model.GetDeclaredSymbol(accessor, cancellationToken);
                    }
                }
            }
            if (!symbol.AccessibilityChangeable())
            {
                return;
            }

            foreach (var accessibility in GetPossibleAccessibilities(model, symbol, node, cancellationToken))
            {
                var modifiers = GetAccessibilityModifiers(accessibility);
                context.RegisterRefactoring(CodeActionFactory.Create(
                                                token.Span,
                                                DiagnosticSeverity.Info,
                                                GettextCatalog.GetString("To " + String.Join(" ", modifiers)),
                                                t =>
                {
                    var newRoot = root.ReplaceNode(
                        node,
                        node.WithoutLeadingTrivia().WithModifiers(modifiers).WithLeadingTrivia(node.GetLeadingTrivia()));

                    return(Task.FromResult(document.WithSyntaxRoot(newRoot)));
                }));
            }
        }