Group refactorings 'Wrap in ...' (#1317)

josefpihrt · web-flow · commit eb5e54623236 · 2023-12-03T15:46:59.000+01:00
diff --git a/ChangeLog.md b/ChangeLog.md
@@ -23,6 +23,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Rename analyzers ([PR](https://github.com/dotnet/roslynator/pull/1314))
   - "Add new line before embedded statement" -> "Put embedded statement on its own line" ([RCS0030](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS0030))
   - "Add new line before statement" -> "Put statement on its own line" ([RCS0033](https://josefpihrt.github.io/docs/roslynator/analyzers/RCS0033))
+- Group refactoring "Wrap in ..." ([PR](https://github.com/dotnet/roslynator/pull/1317))
 
 ### Fixed
 
diff --git a/src/Refactorings/CSharp/Refactorings/EmbeddedStatementRefactoring.cs b/src/Refactorings/CSharp/Refactorings/EmbeddedStatementRefactoring.cs
@@ -14,15 +14,15 @@ public static void ComputeRefactoring(RefactoringContext context, StatementSynta
 
         if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapStatementsInCondition))
         {
-            context.RegisterRefactoring(
+            context.AddNestedCodeAction(
                 WrapInIfStatementRefactoring.Title,
                 ct => WrapInIfStatementRefactoring.Instance.RefactorAsync(context.Document, statement, ct),
                 RefactoringDescriptors.WrapStatementsInCondition);
         }
 
         if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInTryCatch))
         {
-            context.RegisterRefactoring(
+            context.AddNestedCodeAction(
                 WrapLinesInTryCatchRefactoring.Title,
                 ct => WrapLinesInTryCatchRefactoring.Instance.RefactorAsync(context.Document, statement, ct),
                 RefactoringDescriptors.WrapLinesInTryCatch);
diff --git a/src/Refactorings/CSharp/Refactorings/RefactoringContext.cs b/src/Refactorings/CSharp/Refactorings/RefactoringContext.cs
@@ -38,6 +38,8 @@ public RefactoringContext(CodeRefactoringContext underlyingContext, SyntaxNode r
 
     public SyntaxNode Root { get; }
 
+    public ImmutableArray<CodeAction>.Builder NestedCodeActions { get; private set; }
+
     public CancellationToken CancellationToken
     {
         get { return UnderlyingContext.CancellationToken; }
@@ -77,50 +79,33 @@ public bool SupportsCSharp6
     {
         get
         {
-            if (Project.Language == LanguageNames.CSharp)
-            {
-                switch (((CSharpParseOptions)Project.ParseOptions).LanguageVersion)
-                {
-                    case LanguageVersion.CSharp1:
-                    case LanguageVersion.CSharp2:
-                    case LanguageVersion.CSharp3:
-                    case LanguageVersion.CSharp4:
-                    case LanguageVersion.CSharp5:
-                        return false;
-                    default:
-                        return true;
-                }
-            }
-
-            return false;
+            return Project.Language == LanguageNames.CSharp
+                && ((CSharpParseOptions)Project.ParseOptions).LanguageVersion >= LanguageVersion.CSharp6;
         }
     }
 
-    public bool SupportsCSharp7
+    public bool PrefixFieldIdentifierWithUnderscore => (_configOptions ??= Document.GetConfigOptions(Root.SyntaxTree)).GetPrefixFieldIdentifierWithUnderscore();
+
+    public void AddNestedCodeAction(
+        string title,
+        Func<CancellationToken, Task<Document>> createChangedDocument,
+        RefactoringDescriptor descriptor,
+        string additionalEquivalenceKey1 = null,
+        string additionalEquivalenceKey2 = null)
     {
-        get
-        {
-            if (Project.Language == LanguageNames.CSharp)
-            {
-                switch (((CSharpParseOptions)Project.ParseOptions).LanguageVersion)
-                {
-                    case LanguageVersion.CSharp1:
-                    case LanguageVersion.CSharp2:
-                    case LanguageVersion.CSharp3:
-                    case LanguageVersion.CSharp4:
-                    case LanguageVersion.CSharp5:
-                    case LanguageVersion.CSharp6:
-                        return false;
-                    default:
-                        return true;
-                }
-            }
+        NestedCodeActions ??= ImmutableArray.CreateBuilder<CodeAction>();
 
-            return false;
-        }
+        NestedCodeActions.Add(CodeAction.Create(
+            title,
+            createChangedDocument,
+            EquivalenceKey.Create(descriptor, additionalEquivalenceKey1, additionalEquivalenceKey2)));
     }
 
-    public bool PrefixFieldIdentifierWithUnderscore => (_configOptions ??= Document.GetConfigOptions(Root.SyntaxTree)).GetPrefixFieldIdentifierWithUnderscore();
+    public void RegisterNestedCodeActions(string title)
+    {
+        if (NestedCodeActions is not null)
+            UnderlyingContext.RegisterRefactoring(CodeAction.Create(title, NestedCodeActions.ToImmutable(), isInlinable: false));
+    }
 
     public void ThrowIfCancellationRequested()
     {
diff --git a/src/Refactorings/CSharp/Refactorings/SelectedLinesRefactoring.cs b/src/Refactorings/CSharp/Refactorings/SelectedLinesRefactoring.cs
@@ -54,19 +54,21 @@ public static async Task ComputeRefactoringsAsync(RefactoringContext context, Sy
             {
                 if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInRegion))
                 {
-                    context.RegisterRefactoring(
-                        "Wrap in #region",
+                    context.AddNestedCodeAction(
+                        "#region",
                         ct => WrapLinesInRegionRefactoring.Instance.RefactorAsync(document, selectedLines, ct),
                         RefactoringDescriptors.WrapLinesInRegion);
                 }
 
                 if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInPreprocessorDirective))
                 {
-                    context.RegisterRefactoring(
-                        "Wrap in #if",
+                    context.AddNestedCodeAction(
+                        "#if",
                         ct => WrapLinesInPreprocessorDirectiveRefactoring.Instance.RefactorAsync(document, selectedLines, ct),
                         RefactoringDescriptors.WrapLinesInPreprocessorDirective);
                 }
+
+                context.RegisterNestedCodeActions("Wrap in");
             }
 
             if (context.IsRefactoringEnabled(RefactoringDescriptors.RemoveEmptyLines))
diff --git a/src/Refactorings/CSharp/Refactorings/SelectedStatementsRefactoring.cs b/src/Refactorings/CSharp/Refactorings/SelectedStatementsRefactoring.cs
@@ -79,15 +79,15 @@ public static async Task ComputeRefactoringAsync(RefactoringContext context, Sta
 
         if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapStatementsInCondition))
         {
-            context.RegisterRefactoring(
+            context.AddNestedCodeAction(
                 WrapInIfStatementRefactoring.Title,
                 ct => WrapInIfStatementRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct),
                 RefactoringDescriptors.WrapStatementsInCondition);
         }
 
         if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInTryCatch))
         {
-            context.RegisterRefactoring(
+            context.AddNestedCodeAction(
                 WrapLinesInTryCatchRefactoring.Title,
                 ct => WrapLinesInTryCatchRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct),
                 RefactoringDescriptors.WrapLinesInTryCatch);
diff --git a/src/Refactorings/CSharp/Refactorings/WrapStatements/WrapInIfStatementRefactoring.cs b/src/Refactorings/CSharp/Refactorings/WrapStatements/WrapInIfStatementRefactoring.cs
@@ -16,7 +16,7 @@ private WrapInIfStatementRefactoring()
 
     public static WrapInIfStatementRefactoring Instance { get; } = new();
 
-    public const string Title = "Wrap in condition";
+    public const string Title = "'if' statement";
 
     public override IfStatementSyntax CreateStatement(ImmutableArray<StatementSyntax> statements)
     {
diff --git a/src/Refactorings/CSharp/Refactorings/WrapStatements/WrapLinesInTryCatchRefactoring.cs b/src/Refactorings/CSharp/Refactorings/WrapStatements/WrapLinesInTryCatchRefactoring.cs
@@ -9,7 +9,7 @@ namespace Roslynator.CSharp.Refactorings.WrapStatements;
 
 internal sealed class WrapLinesInTryCatchRefactoring : WrapStatementsRefactoring<TryStatementSyntax>
 {
-    public const string Title = "Wrap in try-catch";
+    public const string Title = "try-catch";
 
     private WrapLinesInTryCatchRefactoring()
     {

Original file line number	Diff line number	Diff line change
`@@ -14,15 +14,15 @@ public static void ComputeRefactoring(RefactoringContext context, StatementSynta`
`14`	`14`
`15`	`15`	`if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapStatementsInCondition))`
`16`	`16`	`{`
`17`		`- context.RegisterRefactoring(`
	`17`	`+ context.AddNestedCodeAction(`
`18`	`18`	`WrapInIfStatementRefactoring.Title,`
`19`	`19`	`ct => WrapInIfStatementRefactoring.Instance.RefactorAsync(context.Document, statement, ct),`
`20`	`20`	`RefactoringDescriptors.WrapStatementsInCondition);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInTryCatch))`
`24`	`24`	`{`
`25`		`- context.RegisterRefactoring(`
	`25`	`+ context.AddNestedCodeAction(`
`26`	`26`	`WrapLinesInTryCatchRefactoring.Title,`
`27`	`27`	`ct => WrapLinesInTryCatchRefactoring.Instance.RefactorAsync(context.Document, statement, ct),`
`28`	`28`	`RefactoringDescriptors.WrapLinesInTryCatch);`
Original file line number	Diff line number	Diff line change
`@@ -54,19 +54,21 @@ public static async Task ComputeRefactoringsAsync(RefactoringContext context, Sy`
`54`	`54`	`{`
`55`	`55`	`if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInRegion))`
`56`	`56`	`{`
`57`		`- context.RegisterRefactoring(`
`58`		`- "Wrap in #region",`
	`57`	`+ context.AddNestedCodeAction(`
	`58`	`+ "#region",`
`59`	`59`	`ct => WrapLinesInRegionRefactoring.Instance.RefactorAsync(document, selectedLines, ct),`
`60`	`60`	`RefactoringDescriptors.WrapLinesInRegion);`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInPreprocessorDirective))`
`64`	`64`	`{`
`65`		`- context.RegisterRefactoring(`
`66`		`- "Wrap in #if",`
	`65`	`+ context.AddNestedCodeAction(`
	`66`	`+ "#if",`
`67`	`67`	`ct => WrapLinesInPreprocessorDirectiveRefactoring.Instance.RefactorAsync(document, selectedLines, ct),`
`68`	`68`	`RefactoringDescriptors.WrapLinesInPreprocessorDirective);`
`69`	`69`	`}`
	`70`	`+`
	`71`	`+ context.RegisterNestedCodeActions("Wrap in");`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`if (context.IsRefactoringEnabled(RefactoringDescriptors.RemoveEmptyLines))`
Original file line number	Diff line number	Diff line change
`@@ -79,15 +79,15 @@ public static async Task ComputeRefactoringAsync(RefactoringContext context, Sta`
`79`	`79`
`80`	`80`	`if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapStatementsInCondition))`
`81`	`81`	`{`
`82`		`- context.RegisterRefactoring(`
	`82`	`+ context.AddNestedCodeAction(`
`83`	`83`	`WrapInIfStatementRefactoring.Title,`
`84`	`84`	`ct => WrapInIfStatementRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct),`
`85`	`85`	`RefactoringDescriptors.WrapStatementsInCondition);`
`86`	`86`	`}`
`87`	`87`
`88`	`88`	`if (context.IsRefactoringEnabled(RefactoringDescriptors.WrapLinesInTryCatch))`
`89`	`89`	`{`
`90`		`- context.RegisterRefactoring(`
	`90`	`+ context.AddNestedCodeAction(`
`91`	`91`	`WrapLinesInTryCatchRefactoring.Title,`
`92`	`92`	`ct => WrapLinesInTryCatchRefactoring.Instance.RefactorAsync(context.Document, selectedStatements, ct),`
`93`	`93`	`RefactoringDescriptors.WrapLinesInTryCatch);`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ private WrapInIfStatementRefactoring()`
`16`	`16`
`17`	`17`	`public static WrapInIfStatementRefactoring Instance { get; } = new();`
`18`	`18`
`19`		`- public const string Title = "Wrap in condition";`
	`19`	`+ public const string Title = "'if' statement";`
`20`	`20`
`21`	`21`	`public override IfStatementSyntax CreateStatement(ImmutableArray<StatementSyntax> statements)`
`22`	`22`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace Roslynator.CSharp.Refactorings.WrapStatements;`
`9`	`9`
`10`	`10`	`internal sealed class WrapLinesInTryCatchRefactoring : WrapStatementsRefactoring<TryStatementSyntax>`
`11`	`11`	`{`
`12`		`- public const string Title = "Wrap in try-catch";`
	`12`	`+ public const string Title = "try-catch";`
`13`	`13`
`14`	`14`	`private WrapLinesInTryCatchRefactoring()`
`15`	`15`	`{`