Beispiel #1
0
        private static async Task <Document> SortByValueAsync(
            Document document,
            EnumDeclarationSyntax enumDeclaration,
            ImmutableArray <EnumMemberDeclarationSyntax> selectedMembers,
            CancellationToken cancellationToken)
        {
            SeparatedSyntaxList <EnumMemberDeclarationSyntax> members = enumDeclaration.Members;

            int firstIndex = members.IndexOf(selectedMembers[0]);
            int lastIndex  = members.IndexOf(selectedMembers[selectedMembers.Length - 1]);

            SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            var comparer = new EnumMemberDeclarationValueComparer(semanticModel, cancellationToken);

            IEnumerable <EnumMemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, comparer);

            SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = members
                                                                           .Take(firstIndex)
                                                                           .Concat(sorted)
                                                                           .Concat(members.Skip(lastIndex + 1))
                                                                           .ToSeparatedSyntaxList();

            MemberDeclarationSyntax newNode = enumDeclaration.WithMembers(newMembers);

            return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
        }
        public static async Task ComputeRefactoringAsync(RefactoringContext context, EnumDeclarationSyntax enumDeclaration)
        {
            ImmutableArray <EnumMemberDeclarationSyntax> selectedMembers = enumDeclaration.Members
                                                                           .SkipWhile(f => context.Span.Start > f.Span.Start)
                                                                           .TakeWhile(f => context.Span.End >= f.Span.End)
                                                                           .ToImmutableArray();

            if (selectedMembers.Length > 1)
            {
                if (!EnumMemberDeclarationNameComparer.IsSorted(selectedMembers))
                {
                    context.RegisterRefactoring(
                        "Sort enum members by name",
                        cancellationToken => SortByNameAsync(context.Document, enumDeclaration, selectedMembers, cancellationToken));
                }

                if (selectedMembers.Any(f => f.EqualsValue?.Value != null))
                {
                    SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);

                    if (!EnumMemberDeclarationValueComparer.IsSorted(selectedMembers, semanticModel, context.CancellationToken))
                    {
                        context.RegisterRefactoring(
                            "Sort enum members by value",
                            cancellationToken => SortByValueAsync(context.Document, enumDeclaration, selectedMembers, cancellationToken));
                    }
                }
            }
        }
Beispiel #3
0
        public static async Task ComputeRefactoringAsync(
            RefactoringContext context,
            EnumDeclarationSyntax enumDeclaration,
            SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selection)
        {
            ImmutableArray <EnumMemberDeclarationSyntax> selectedMembers = selection.SelectedItems;

            if (!EnumMemberDeclarationNameComparer.IsSorted(selectedMembers))
            {
                context.RegisterRefactoring(
                    "Sort enum members by name",
                    cancellationToken => SortByNameAsync(context.Document, enumDeclaration, selectedMembers, cancellationToken));
            }

            if (selectedMembers.Any(f => f.EqualsValue?.Value != null))
            {
                SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);

                if (!EnumMemberDeclarationValueComparer.IsSorted(selectedMembers, semanticModel, context.CancellationToken))
                {
                    context.RegisterRefactoring(
                        "Sort enum members by value",
                        cancellationToken => SortByValueAsync(context.Document, enumDeclaration, selectedMembers, cancellationToken));
                }
            }
        }
        private static async Task <Document> SortByValueAsync(
            Document document,
            EnumDeclarationSyntax enumDeclaration,
            SeparatedSyntaxListSelection <EnumMemberDeclarationSyntax> selectedMembers,
            CancellationToken cancellationToken)
        {
            SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);

            SpecialType enumSpecialType = semanticModel.GetDeclaredSymbol(enumDeclaration, cancellationToken).EnumUnderlyingType.SpecialType;

            var comparer = new EnumMemberDeclarationValueComparer(EnumValueComparer.GetInstance(enumSpecialType), semanticModel, cancellationToken);

            IEnumerable <EnumMemberDeclarationSyntax> sorted = selectedMembers.OrderBy(f => f, comparer);

            SeparatedSyntaxList <EnumMemberDeclarationSyntax> newMembers = enumDeclaration
                                                                           .Members
                                                                           .ReplaceRange(selectedMembers.FirstIndex, selectedMembers.Count, sorted);

            MemberDeclarationSyntax newNode = enumDeclaration.WithMembers(newMembers);

            return(await document.ReplaceNodeAsync(enumDeclaration, newNode, cancellationToken).ConfigureAwait(false));
        }