dotnet · josefpihrt · Dec 1, 2023 · Dec 1, 2023 · Dec 1, 2023 · Dec 1, 2023
diff --git a/ChangeLog.md b/ChangeLog.md
@@ -15,8 +15,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
-- Improve refactoring 'Remove comment' [RR0098](https://josefpihrt.github.io/docs/roslynator/refactorings/RR0098) ([PR](https://github.com/dotnet/roslynator/pull/1284))
+- Improve refactoring "Remove comment" [RR0098](https://josefpihrt.github.io/docs/roslynator/refactorings/RR0098) ([PR](https://github.com/dotnet/roslynator/pull/1284))
 - Remove trailing dot from analyzer's title ([PR](https://github.com/dotnet/roslynator/pull/1298))
+- Group code fix "Change accessibility to ..." ([PR](https://github.com/dotnet/roslynator/pull/1305))
 
 ### Fixed
 
@@ -30,6 +31,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix analyzer [RCS1176](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1176) ([PR](https://github.com/dotnet/roslynator/pull/1291))
 - Fix analyzer [RCS1197](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1197) ([PR](https://github.com/dotnet/roslynator/pull/1166))
 - Fix analyzer [RCS1093](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS1093) ([PR](https://github.com/dotnet/roslynator/pull/1296))
+- [Testing] Detect nested code actions ([PR](https://github.com/dotnet/roslynator/pull/1305))
 
 ## [4.6.4] - 2023-11-24
 

diff --git a/src/CSharp/CSharp/SyntaxAccessibility.cs b/src/CSharp/CSharp/SyntaxAccessibility.cs
@@ -62,6 +62,8 @@ public static Accessibility GetDefaultAccessibility(SyntaxNode declaration)
                 return SyntaxAccessibility<EnumMemberDeclarationSyntax>.Instance.GetDefaultAccessibility((EnumMemberDeclarationSyntax)declaration);
             case SyntaxKind.NamespaceDeclaration:
                 return SyntaxAccessibility<NamespaceDeclarationSyntax>.Instance.GetDefaultAccessibility((NamespaceDeclarationSyntax)declaration);
+            case SyntaxKind.FileScopedNamespaceDeclaration:
+                return SyntaxAccessibility<FileScopedNamespaceDeclarationSyntax>.Instance.GetDefaultAccessibility((FileScopedNamespaceDeclarationSyntax)declaration);
             case SyntaxKind.GetAccessorDeclaration:
             case SyntaxKind.SetAccessorDeclaration:
             case SyntaxKind.AddAccessorDeclaration:
@@ -125,6 +127,8 @@ public static Accessibility GetDefaultExplicitAccessibility(SyntaxNode declarati
                 return SyntaxAccessibility<EnumMemberDeclarationSyntax>.Instance.GetDefaultExplicitAccessibility((EnumMemberDeclarationSyntax)declaration);
             case SyntaxKind.NamespaceDeclaration:
                 return SyntaxAccessibility<NamespaceDeclarationSyntax>.Instance.GetDefaultExplicitAccessibility((NamespaceDeclarationSyntax)declaration);
+            case SyntaxKind.FileScopedNamespaceDeclaration:
+                return SyntaxAccessibility<FileScopedNamespaceDeclarationSyntax>.Instance.GetDefaultExplicitAccessibility((FileScopedNamespaceDeclarationSyntax)declaration);
             case SyntaxKind.GetAccessorDeclaration:
             case SyntaxKind.SetAccessorDeclaration:
             case SyntaxKind.AddAccessorDeclaration:
@@ -188,6 +192,8 @@ public static Accessibility GetAccessibility(SyntaxNode declaration)
                 return SyntaxAccessibility<EnumMemberDeclarationSyntax>.Instance.GetAccessibility((EnumMemberDeclarationSyntax)declaration);
             case SyntaxKind.NamespaceDeclaration:
                 return SyntaxAccessibility<NamespaceDeclarationSyntax>.Instance.GetAccessibility((NamespaceDeclarationSyntax)declaration);
+            case SyntaxKind.FileScopedNamespaceDeclaration:
+                return SyntaxAccessibility<FileScopedNamespaceDeclarationSyntax>.Instance.GetAccessibility((FileScopedNamespaceDeclarationSyntax)declaration);
             case SyntaxKind.GetAccessorDeclaration:
             case SyntaxKind.SetAccessorDeclaration:
             case SyntaxKind.AddAccessorDeclaration:
@@ -251,6 +257,8 @@ public static Accessibility GetExplicitAccessibility(SyntaxNode declaration)
                 return SyntaxAccessibility<EnumMemberDeclarationSyntax>.Instance.GetExplicitAccessibility((EnumMemberDeclarationSyntax)declaration);
             case SyntaxKind.NamespaceDeclaration:
                 return SyntaxAccessibility<NamespaceDeclarationSyntax>.Instance.GetExplicitAccessibility((NamespaceDeclarationSyntax)declaration);
+            case SyntaxKind.FileScopedNamespaceDeclaration:
+                return SyntaxAccessibility<FileScopedNamespaceDeclarationSyntax>.Instance.GetExplicitAccessibility((FileScopedNamespaceDeclarationSyntax)declaration);
             case SyntaxKind.GetAccessorDeclaration:
             case SyntaxKind.SetAccessorDeclaration:
             case SyntaxKind.AddAccessorDeclaration:
@@ -334,7 +342,7 @@ public static bool IsPubliclyVisible(MemberDeclarationSyntax declaration)
 
         do
         {
-            if (declaration.IsKind(SyntaxKind.NamespaceDeclaration))
+            if (declaration.IsKind(SyntaxKind.NamespaceDeclaration, SyntaxKind.FileScopedNamespaceDeclaration))
                 return true;
 
             if (!GetAccessibility(declaration).Is(
@@ -411,6 +419,7 @@ public static bool IsValidAccessibility(SyntaxNode node, Accessibility accessibi
         switch (node.Parent?.Kind())
         {
             case SyntaxKind.NamespaceDeclaration:
+            case SyntaxKind.FileScopedNamespaceDeclaration:
             case SyntaxKind.CompilationUnit:
                 {
                     return accessibility.Is(Accessibility.Public, Accessibility.Internal);

diff --git a/src/CSharp/CSharp/SyntaxAccessibility`1.cs b/src/CSharp/CSharp/SyntaxAccessibility`1.cs
@@ -61,6 +61,9 @@ private static object GetInstance()
         if (typeof(TNode) == typeof(NamespaceDeclarationSyntax))
             return new NamespaceAccessibility();
 
+        if (typeof(TNode) == typeof(FileScopedNamespaceDeclarationSyntax))
+            return new FileScopedNamespaceAccessibility();
+
         if (typeof(TNode) == typeof(OperatorDeclarationSyntax))
             return new OperatorAccessibility();
 
@@ -772,6 +775,38 @@ public override Accessibility GetExplicitAccessibility(NamespaceDeclarationSynta
         }
     }
 
+    private class FileScopedNamespaceAccessibility : SyntaxAccessibility<FileScopedNamespaceDeclarationSyntax>
+    {
+        public override Accessibility GetDefaultAccessibility(FileScopedNamespaceDeclarationSyntax declaration)
+        {
+            if (declaration is null)
+                throw new ArgumentNullException(nameof(declaration));
+
+            return Accessibility.Public;
+        }
+
+        public override Accessibility GetDefaultExplicitAccessibility(FileScopedNamespaceDeclarationSyntax declaration)
+        {
+            if (declaration is null)
+                throw new ArgumentNullException(nameof(declaration));
+
+            return Accessibility.NotApplicable;
+        }
+
+        public override Accessibility GetAccessibility(FileScopedNamespaceDeclarationSyntax declaration)
+        {
+            if (declaration is null)
+                throw new ArgumentNullException(nameof(declaration));
+
+            return Accessibility.Public;
+        }
+
+        public override Accessibility GetExplicitAccessibility(FileScopedNamespaceDeclarationSyntax declaration)
+        {
+            return Accessibility.NotApplicable;
+        }
+    }
+
     private class OperatorAccessibility : SyntaxAccessibility<OperatorDeclarationSyntax>
     {
         public override Accessibility GetDefaultAccessibility(OperatorDeclarationSyntax declaration)

diff --git a/src/Refactorings/CSharp/Refactorings/AccessModifierRefactoring.cs b/src/Refactorings/CSharp/Refactorings/AccessModifierRefactoring.cs
@@ -4,6 +4,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Roslynator.CSharp.Syntax;
@@ -40,23 +41,31 @@ public static async Task ComputeRefactoringsAsync(RefactoringContext context, Sy
                     syntaxReferences,
                     f => (MemberDeclarationSyntax)f.GetSyntax(context.CancellationToken));
 
+                ImmutableArray<CodeAction>.Builder typeDeclarationActions = ImmutableArray.CreateBuilder<CodeAction>();
+
                 foreach (Accessibility accessibility in AvailableAccessibilities)
                 {
                     if (accessibility != modifiersInfo.ExplicitAccessibility
                         && SyntaxAccessibility.IsValidAccessibility(node, accessibility))
                     {
-                        context.RegisterRefactoring(
-                            GetTitle(accessibility),
+                        typeDeclarationActions.Add(CodeActionFactory.Create(
+                            SyntaxFacts.GetText(accessibility),
                             ct => RefactorAsync(context.Solution, memberDeclarations, accessibility, ct),
                             RefactoringDescriptors.ChangeAccessibility,
-                            accessibility.ToString());
+                            accessibility.ToString()));
                     }
                 }
 
+                context.RegisterRefactoring(
+                    "Change accessibility to",
+                    typeDeclarationActions.ToImmutable());
+
                 return;
             }
         }
 
+        ImmutableArray<CodeAction>.Builder codeActions = ImmutableArray.CreateBuilder<CodeAction>();
+
         foreach (Accessibility accessibility in AvailableAccessibilities)
         {
             if (accessibility == modifiersInfo.ExplicitAccessibility)
@@ -70,23 +79,27 @@ public static async Task ComputeRefactoringsAsync(RefactoringContext context, Sy
             {
                 if (SyntaxAccessibility.IsValidAccessibility(node, accessibility, ignoreOverride: true))
                 {
-                    context.RegisterRefactoring(
-                        GetTitle(accessibility),
+                    codeActions.Add(CodeActionFactory.Create(
+                        SyntaxFacts.GetText(accessibility),
                         ct => RefactorAsync(context.Solution, symbol, accessibility, ct),
                         RefactoringDescriptors.ChangeAccessibility,
-                        accessibility.ToString());
+                        accessibility.ToString()));
                 }
             }
             else if (SyntaxAccessibility.IsValidAccessibility(node, accessibility))
             {
-                context.RegisterRefactoring(
-                    GetTitle(accessibility),
+                codeActions.Add(CodeActionFactory.Create(
+                    SyntaxFacts.GetText(accessibility),
                     ct => RefactorAsync(context.Document, node, accessibility, ct),
                     RefactoringDescriptors.ChangeAccessibility,
-                    accessibility.ToString());
+                    accessibility.ToString()));
             }
         }
 
+        context.RegisterRefactoring(
+            "Change accessibility to",
+            codeActions.ToImmutable());
+
         ISymbol GetBaseSymbolOrDefault(SemanticModel semanticModel, CancellationToken cancellationToken)
         {
             if (modifiersInfo.GetFilter().HasAnyFlag(ModifierFilter.AbstractVirtualOverride))

diff --git a/src/Refactorings/CSharp/Refactorings/RefactoringContext.cs b/src/Refactorings/CSharp/Refactorings/RefactoringContext.cs
@@ -2,6 +2,8 @@
 
 using System;
 using System.Collections;
+using System.Collections.Immutable;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
@@ -130,6 +132,15 @@ public Task<SemanticModel> GetSemanticModelAsync()
         return Document.GetSemanticModelAsync(CancellationToken);
     }
 
+    public void RegisterRefactoring(
+        string title,
+        ImmutableArray<CodeAction> nestedActions,
+        bool isInlinable = false)
+    {
+        if (nestedActions.Any())
+            RegisterRefactoring(CodeAction.Create(title, nestedActions, isInlinable));
+    }
+
     public void RegisterRefactoring(
         string title,
         Func<CancellationToken, Task<Document>> createChangedDocument,

diff --git a/src/Refactorings/CSharp/Refactorings/SelectedMemberDeclarationsRefactoring.cs b/src/Refactorings/CSharp/Refactorings/SelectedMemberDeclarationsRefactoring.cs
@@ -1,9 +1,9 @@
 // Copyright (c) .NET Foundation and Contributors. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Roslynator.CSharp.Analysis;
@@ -12,14 +12,6 @@ namespace Roslynator.CSharp.Refactorings;
 
 internal static class SelectedMemberDeclarationsRefactoring
 {
-    public static ImmutableDictionary<Accessibility, string> _accessibilityIdentifierMap = ImmutableDictionary.CreateRange(new[]
-        {
-            new KeyValuePair<Accessibility, string>(Accessibility.Public, EquivalenceKey.Create(RefactoringDescriptors.ChangeAccessibility.Id, nameof(Accessibility.Public))),
-            new KeyValuePair<Accessibility, string>(Accessibility.Internal, EquivalenceKey.Create(RefactoringDescriptors.ChangeAccessibility.Id, nameof(Accessibility.Internal))),
-            new KeyValuePair<Accessibility, string>(Accessibility.Protected, EquivalenceKey.Create(RefactoringDescriptors.ChangeAccessibility.Id, nameof(Accessibility.Protected))),
-            new KeyValuePair<Accessibility, string>(Accessibility.Private, EquivalenceKey.Create(RefactoringDescriptors.ChangeAccessibility.Id, nameof(Accessibility.Private))),
-        });
-
     public static async Task ComputeRefactoringAsync(RefactoringContext context, MemberDeclarationListSelection selectedMembers)
     {
         if (context.IsRefactoringEnabled(RefactoringDescriptors.ChangeAccessibility)
@@ -33,10 +25,16 @@ public static async Task ComputeRefactoringAsync(RefactoringContext context, Mem
             {
                 bool canHaveMultipleDeclarations = CanHaveMultipleDeclarations();
 
-                TryRegisterRefactoring(validAccessibilities, Accessibility.Public, canHaveMultipleDeclarations);
-                TryRegisterRefactoring(validAccessibilities, Accessibility.Internal, canHaveMultipleDeclarations);
-                TryRegisterRefactoring(validAccessibilities, Accessibility.Protected, canHaveMultipleDeclarations);
-                TryRegisterRefactoring(validAccessibilities, Accessibility.Private, canHaveMultipleDeclarations);
+                ImmutableArray<CodeAction>.Builder codeActions = ImmutableArray.CreateBuilder<CodeAction>();
+
+                TryAddCodeAction(validAccessibilities, Accessibility.Public, canHaveMultipleDeclarations, codeActions);
+                TryAddCodeAction(validAccessibilities, Accessibility.Internal, canHaveMultipleDeclarations, codeActions);
+                TryAddCodeAction(validAccessibilities, Accessibility.Protected, canHaveMultipleDeclarations, codeActions);
+                TryAddCodeAction(validAccessibilities, Accessibility.Private, canHaveMultipleDeclarations, codeActions);
+
+                context.RegisterRefactoring(
+                    "Change accessibility to",
+                    codeActions.ToImmutable());
             }
         }
 
@@ -58,30 +56,41 @@ public static async Task ComputeRefactoringAsync(RefactoringContext context, Mem
             AddEmptyLineBetweenDeclarationsRefactoring.ComputeRefactoring(context, selectedMembers);
         }
 
-        void TryRegisterRefactoring(AccessibilityFilter accessibilities, Accessibility accessibility, bool canHaveMultipleDeclarations)
+        void TryAddCodeAction(AccessibilityFilter accessibilities, Accessibility accessibility, bool canHaveMultipleDeclarations, ImmutableArray<CodeAction>.Builder codeActions)
+        {
+            CodeAction codeAction = TryCreateCodeAction(accessibilities, accessibility, canHaveMultipleDeclarations);
+
+            if (codeAction is not null)
+                codeActions.Add(codeAction);
+        }
+
+        CodeAction TryCreateCodeAction(AccessibilityFilter accessibilities, Accessibility accessibility, bool canHaveMultipleDeclarations)
         {
             if ((accessibilities & accessibility.GetAccessibilityFilter()) != 0)
             {
                 if (canHaveMultipleDeclarations)
                 {
-                    context.RegisterRefactoring(
-                        ChangeAccessibilityRefactoring.GetTitle(accessibility),
+                    return CodeActionFactory.Create(
+                        SyntaxFacts.GetText(accessibility),
                         async ct =>
                         {
                             SemanticModel semanticModel = await context.Document.GetSemanticModelAsync(ct).ConfigureAwait(false);
                             return await ChangeAccessibilityRefactoring.RefactorAsync(context.Document.Solution(), selectedMembers, accessibility, semanticModel, ct).ConfigureAwait(false);
                         },
-                        _accessibilityIdentifierMap[accessibility]);
+                        RefactoringDescriptors.ChangeAccessibility,
+                        accessibility.ToString());
                 }
                 else
                 {
-                    context.RegisterRefactoring(
-                        ChangeAccessibilityRefactoring.GetTitle(accessibility),
+                    return CodeActionFactory.Create(
+                        SyntaxFacts.GetText(accessibility),
                         ct => ChangeAccessibilityRefactoring.RefactorAsync(context.Document, selectedMembers, accessibility, ct),
                         RefactoringDescriptors.ChangeAccessibility,
                         accessibility.ToString());
                 }
             }
+
+            return null;
         }
 
         bool CanHaveMultipleDeclarations()

diff --git a/src/Tests/Testing.Common/Extensions/TestExtensions.cs b/src/Tests/Testing.Common/Extensions/TestExtensions.cs
@@ -2,9 +2,11 @@
 
 using System;
 using System.Collections.Immutable;
+using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Simplification;
 using Microsoft.CodeAnalysis.Text;
@@ -13,6 +15,18 @@ namespace Roslynator;
 
 internal static class TestExtensions
 {
+    public static ImmutableArray<CodeAction> GetNestedActions(this CodeAction codeAction)
+    {
+        Type type = codeAction.GetType();
+        if (type.Name == "CodeActionWithNestedActions")
+        {
+            PropertyInfo propertyInfo = type.GetProperty("NestedCodeActions", BindingFlags.NonPublic | BindingFlags.Instance);
+            return (ImmutableArray<CodeAction>)propertyInfo.GetValue(codeAction);
+        }
+
+        return ImmutableArray<CodeAction>.Empty;
+    }
+
     public static async Task<SyntaxNode?> GetSyntaxRootAsync(
         this Document document,
         bool simplify,