public static async Task ComputeRefactoringsAsync(RefactoringContext context, AttributeArgumentListSyntax argumentList)
        {
            if (!argumentList.Arguments.Any())
            {
                return;
            }

            await AttributeArgumentParameterNameRefactoring.ComputeRefactoringsAsync(context, argumentList).ConfigureAwait(false);

            if (context.IsRefactoringEnabled(RefactoringIdentifiers.DuplicateArgument))
            {
                DuplicateAttributeArgumentRefactoring.ComputeRefactoring(context, argumentList);
            }

            if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatArgumentList) &&
                context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(argumentList))
            {
                if (argumentList.IsSingleLine())
                {
                    if (argumentList.Arguments.Count > 1)
                    {
                        context.RegisterRefactoring(
                            "Format arguments on separate lines",
                            ct => SyntaxFormatter.ToMultiLineAsync(context.Document, argumentList, ct));
                    }
                }
                else
                {
                    context.RegisterRefactoring(
                        "Format arguments on a single line",
                        ct => SyntaxFormatter.ToSingleLineAsync(context.Document, argumentList, ct));
                }
            }
        }
        public static async Task ComputeRefactoringsAsync(RefactoringContext context, AttributeArgumentListSyntax argumentList)
        {
            if (argumentList.Arguments.Count == 0)
            {
                return;
            }

            await AttributeArgumentParameterNameRefactoring.ComputeRefactoringsAsync(context, argumentList).ConfigureAwait(false);

            DuplicateAttributeArgumentRefactoring.ComputeRefactoring(context, argumentList);

            if (context.IsRefactoringEnabled(RefactoringIdentifiers.FormatArgumentList) &&
                (context.Span.IsEmpty || context.Span.IsBetweenSpans(argumentList)))
            {
                if (argumentList.IsSingleLine())
                {
                    if (argumentList.Arguments.Count > 1)
                    {
                        context.RegisterRefactoring(
                            "Format each argument on a separate line",
                            cancellationToken =>
                        {
                            return(FormatAttributeArgumentListRefactoring.FormatEachArgumentOnSeparateLineAsync(
                                       context.Document,
                                       argumentList,
                                       cancellationToken));
                        });
                    }
                }
                else
                {
                    string title = (argumentList.Arguments.Count == 1)
                            ? "Format argument on a single line"
                            : "Format all arguments on a single line";

                    context.RegisterRefactoring(
                        title,
                        cancellationToken =>
                    {
                        return(FormatAttributeArgumentListRefactoring.FormatAllArgumentsOnSingleLineAsync(
                                   context.Document,
                                   argumentList,
                                   cancellationToken));
                    });
                }
            }
        }
        public static async Task ComputeRefactoringsAsync(RefactoringContext context, AttributeArgumentListSyntax argumentList)
        {
            if (!argumentList.Arguments.Any())
            {
                return;
            }

            await AttributeArgumentParameterNameRefactoring.ComputeRefactoringsAsync(context, argumentList).ConfigureAwait(false);

            if (context.IsRefactoringEnabled(RefactoringDescriptors.CopyArgument))
            {
                CopyAttributeArgumentRefactoring.ComputeRefactoring(context, argumentList);
            }

            if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapArguments) &&
                context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(argumentList))
            {
                if (argumentList.IsSingleLine())
                {
                    if (argumentList.Arguments.Count > 1)
                    {
                        context.RegisterRefactoring(
                            "Wrap arguments",
                            ct => SyntaxFormatter.WrapArgumentsAsync(context.Document, argumentList, ct),
                            RefactoringDescriptors.WrapArguments);
                    }
                }
                else if (argumentList.DescendantTrivia(argumentList.Span).All(f => f.IsWhitespaceOrEndOfLineTrivia()))
                {
                    context.RegisterRefactoring(
                        "Unwrap arguments",
                        ct => SyntaxFormatter.UnwrapExpressionAsync(context.Document, argumentList, ct),
                        RefactoringDescriptors.WrapArguments);
                }
            }
        }