Remove all remaining MyCodeAction types in the repo

Follow up to dotnet#60480 and dotnet#60557
mavasani · May 2, 2022 · 4015b93 · 4015b93
1 parent b16b817
commit 4015b93
Show file tree

Hide file tree

Showing 82 changed files with 373 additions and 761 deletions.
diff --git a/src/Analyzers/Core/CodeFixes/UnsealClass/AbstractUnsealClassCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UnsealClass/AbstractUnsealClassCodeFixProvider.cs
@@ -45,9 +45,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 if (definition != null && definition.DeclaringSyntaxReferences.Length > 0)
                 {
                     context.RegisterCodeFix(
-                        new MyCodeAction(
+                        CodeAction.Create(
                             string.Format(TitleFormat, type.Name),
-                            c => UnsealDeclarationsAsync(document.Project.Solution, definition.DeclaringSyntaxReferences, c)),
+                            c => UnsealDeclarationsAsync(document.Project.Solution, definition.DeclaringSyntaxReferences, c),
+                            nameof(AbstractUnsealClassCodeFixProvider)),
                         context.Diagnostics);
                 }
             }
@@ -83,13 +84,5 @@ private static async Task<Solution> UnsealDeclarationsAsync(
 
             return solution;
         }
-
-        private sealed class MyCodeAction : CustomCodeActions.SolutionChangeAction
-        {
-            public MyCodeAction(string title, Func<CancellationToken, Task<Solution>> createChangedSolution)
-                : base(title, createChangedSolution, title)
-            {
-            }
-        }
     }
 }
diff --git a/src/EditorFeatures/CSharpTest/CodeActions/Preview/PreviewTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/Preview/PreviewTests.cs
@@ -49,16 +49,16 @@ private class MyCodeRefactoringProvider : CodeRefactoringProvider
         {
             public sealed override Task ComputeRefactoringsAsync(CodeRefactoringContext context)
             {
-                var codeAction = new MyCodeAction(context.Document);
+                var codeAction = new TestCodeAction(context.Document);
                 context.RegisterRefactoring(codeAction, context.Span);
                 return Task.CompletedTask;
             }
 
-            private class MyCodeAction : CodeAction
+            private class TestCodeAction : CodeAction
             {
                 private readonly Document _oldDocument;
 
-                public MyCodeAction(Document document)
+                public TestCodeAction(Document document)
                     => _oldDocument = document;
 
                 public override string Title

diff --git a/src/EditorFeatures/VisualBasicTest/CodeActions/Preview/PreviewTests.vb b/src/EditorFeatures/VisualBasicTest/CodeActions/Preview/PreviewTests.vb
@@ -26,12 +26,12 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CodeRefactorings
 
         Private Class MyCodeRefactoringProvider : Inherits CodeRefactoringProvider
             Public NotOverridable Overrides Function ComputeRefactoringsAsync(context As CodeRefactoringContext) As Task
-                Dim codeAction = New MyCodeAction(context.Document)
+                Dim codeAction = New TestCodeAction(context.Document)
                 context.RegisterRefactoring(codeAction, context.Span)
                 Return Task.CompletedTask
             End Function
 
-            Private Class MyCodeAction : Inherits CodeAction
+            Private Class TestCodeAction : Inherits CodeAction
                 Private ReadOnly _oldDocument As Document
 
                 Public Sub New(oldDocument As Document)

diff --git a/...eatures/CSharp/Portable/AssignOutParameters/AbstractAssignOutParametersCodeFixProvider.cs b/...eatures/CSharp/Portable/AssignOutParameters/AbstractAssignOutParametersCodeFixProvider.cs
@@ -165,13 +165,5 @@ protected static ImmutableArray<SyntaxNode> GenerateAssignmentStatements(
 
             return result.ToImmutableAndFree();
         }
-
-        protected class MyCodeAction : CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(title, createChangedDocument, title)
-            {
-            }
-        }
     }
 }
diff --git a/...Features/CSharp/Portable/AssignOutParameters/AssignOutParametersAtStartCodeFixProvider.cs b/...Features/CSharp/Portable/AssignOutParameters/AssignOutParametersAtStartCodeFixProvider.cs
@@ -9,6 +9,7 @@
 using System.Composition;
 using System.Linq;
 using System.Threading;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Editing;
@@ -50,7 +51,10 @@ statement.Parent is BlockSyntax block &&
             }
 
             context.RegisterCodeFix(
-                new MyCodeAction(CSharpFeaturesResources.Assign_out_parameters_at_start, GetDocumentUpdater(context)),
+                CodeAction.Create(
+                    CSharpFeaturesResources.Assign_out_parameters_at_start,
+                    GetDocumentUpdater(context),
+                    nameof(CSharpFeaturesResources.Assign_out_parameters_at_start)),
                 context.Diagnostics);
         }
 

diff --git a/...ion/CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs b/...ion/CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs
@@ -43,8 +43,10 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
             var conditionalExpression = token.GetAncestor<ConditionalExpressionSyntax>();
             if (conditionalExpression != null)
             {
-                var documentChangeAction = new MyCodeAction(
-                    c => GetChangedDocumentAsync(context.Document, conditionalExpression.SpanStart, c));
+                var documentChangeAction = CodeAction.Create(
+                    CSharpFeaturesResources.Add_parentheses_around_conditional_expression_in_interpolated_string,
+                    c => GetChangedDocumentAsync(context.Document, conditionalExpression.SpanStart, c),
+                    nameof(CSharpFeaturesResources.Add_parentheses_around_conditional_expression_in_interpolated_string));
                 context.RegisterCodeFix(documentChangeAction, diagnostic);
             }
         }
@@ -122,15 +124,5 @@ private static async Task<Document> InsertCloseParenthesisAsync(
             var newRoot = root.ReplaceNode(parenthesizedExpression, parenthesizedExpressionWithClosingParen);
             return document.WithSyntaxRoot(newRoot);
         }
-
-        private class MyCodeAction : CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(CSharpFeaturesResources.Add_parentheses_around_conditional_expression_in_interpolated_string,
-                       createChangedDocument,
-                       CSharpFeaturesResources.Add_parentheses_around_conditional_expression_in_interpolated_string)
-            {
-            }
-        }
     }
 }
diff --git a/...ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs b/...ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs
@@ -12,6 +12,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
@@ -59,8 +60,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 
             context.RegisterRefactoring(
-                new MyCodeAction(
-                    c => UpdateDocumentAsync(root, document, parentBlock, localFunction, c)),
+                CodeAction.Create(
+                    CSharpFeaturesResources.Convert_to_method,
+                    c => UpdateDocumentAsync(root, document, parentBlock, localFunction, c),
+                    nameof(CSharpFeaturesResources.Convert_to_method)),
                 localFunction.Span);
         }
 
@@ -312,13 +315,5 @@ private static string GenerateUniqueMethodName(ISymbol declaredSymbol)
                 baseName: declaredSymbol.Name,
                 reservedNames: declaredSymbol.ContainingType.GetMembers().Select(m => m.Name));
         }
-
-        private sealed class MyCodeAction : CodeActions.CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(CSharpFeaturesResources.Convert_to_method, createChangedDocument, nameof(CSharpFeaturesResources.Convert_to_method))
-            {
-            }
-        }
     }
 }
diff --git a/.../CSharp/Portable/CodeRefactorings/EnableNullable/EnableNullableCodeRefactoringProvider.cs b/.../CSharp/Portable/CodeRefactorings/EnableNullable/EnableNullableCodeRefactoringProvider.cs
@@ -59,7 +59,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             }
 
             context.RegisterRefactoring(
-                new MyCodeAction((purpose, cancellationToken) => EnableNullableReferenceTypesAsync(document.Project, purpose, cancellationToken)));
+                new CodeActionWithPurpose((purpose, cancellationToken) => EnableNullableReferenceTypesAsync(document.Project, purpose, cancellationToken)));
         }
 
         private static async Task<Solution> EnableNullableReferenceTypesAsync(Project project, CodeActionPurpose purpose, CancellationToken cancellationToken)
@@ -252,11 +252,11 @@ private enum CodeActionPurpose
             Apply,
         }
 
-        private sealed class MyCodeAction : CodeAction.SolutionChangeAction
+        private sealed class CodeActionWithPurpose : CodeAction.SolutionChangeAction
         {
             private readonly Func<CodeActionPurpose, CancellationToken, Task<Solution>> _createChangedSolution;
 
-            public MyCodeAction(Func<CodeActionPurpose, CancellationToken, Task<Solution>> createChangedSolution)
+            public CodeActionWithPurpose(Func<CodeActionPurpose, CancellationToken, Task<Solution>> createChangedSolution)
                 : base(
                     CSharpFeaturesResources.Enable_nullable_reference_types_in_project,
                     cancellationToken => createChangedSolution(CodeActionPurpose.Apply, cancellationToken),

diff --git a/...Sharp/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.cs b/...Sharp/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.cs
@@ -91,7 +91,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
 
             context.RegisterRefactoring(
-                new MyCodeAction(c => InlineTemporaryAsync(document, variableDeclarator, c)),
+                CodeAction.Create(
+                    CSharpFeaturesResources.Inline_temporary_variable,
+                    c => InlineTemporaryAsync(document, variableDeclarator, c),
+                    nameof(CSharpFeaturesResources.Inline_temporary_variable)),
                 variableDeclarator.Span);
         }
 
@@ -442,13 +445,5 @@ private static bool IsInDeconstructionAssignmentLeft(ExpressionSyntax node)
 
             return false;
         }
-
-        private class MyCodeAction : CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(CSharpFeaturesResources.Inline_temporary_variable, createChangedDocument, nameof(CSharpFeaturesResources.Inline_temporary_variable))
-            {
-            }
-        }
     }
 }
diff --git a/...able/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs b/...able/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs
@@ -66,9 +66,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             }
 
             context.RegisterRefactoring(
-                new MyCodeAction(
+                CodeAction.Create(
                     Title,
-                    c => UpdateDocumentAsync(document, declaredType, c)),
+                    c => UpdateDocumentAsync(document, declaredType, c),
+                    nameof(Title)),
                 declaredType.Span);
         }
 
@@ -130,13 +131,5 @@ private async Task<Document> UpdateDocumentAsync(Document document, TypeSyntax t
             var newRoot = editor.GetChangedRoot();
             return document.WithSyntaxRoot(newRoot);
         }
-
-        private class MyCodeAction : CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
-                : base(title, createChangedDocument, title)
-            {
-            }
-        }
     }
 }
diff --git a/...able/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs b/...able/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs
@@ -10,6 +10,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.CSharp.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
@@ -59,7 +60,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
 
             context.RegisterRefactoring(
-                new MyCodeAction(
+                CodeAction.Create(
                     CSharpFeaturesResources.Use_recursive_patterns,
                     _ => Task.FromResult(document.WithSyntaxRoot(replacementFunc(root))),
                     nameof(CSharpFeaturesResources.Use_recursive_patterns)));
@@ -502,13 +503,5 @@ when canConvertToSubpattern(name, arg) && !memberAccess.Expression.IsKind(Syntax
                 }
             }
         }
-
-        private sealed class MyCodeAction : CodeActions.CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument, string equivalenceKey)
-                : base(title, createChangedDocument, equivalenceKey)
-            {
-            }
-        }
     }
 }
diff --git a/...ndVerbatimString/AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs b/...ndVerbatimString/AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs
@@ -56,15 +56,15 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex
             if (IsVerbatim(literalExpression))
             {
                 // always offer to convert from verbatim string to normal string.
-                context.RegisterRefactoring(new MyCodeAction(
+                context.RegisterRefactoring(new PriorityBasedCodeAction(
                     CSharpFeaturesResources.Convert_to_regular_string,
                     c => ConvertToRegularStringAsync(document, literalExpression, c)));
             }
             else if (ContainsSimpleEscape(charService, subStringTokens))
             {
                 // Offer to convert to a verbatim string if the normal string contains simple
                 // escapes that can be directly embedded in the verbatim string.
-                context.RegisterRefactoring(new MyCodeAction(
+                context.RegisterRefactoring(new PriorityBasedCodeAction(
                     CSharpFeaturesResources.Convert_to_verbatim_string,
                     c => ConvertToVerbatimStringAsync(document, literalExpression, c)));
             }
@@ -177,7 +177,7 @@ private static bool ContainsSimpleEscape(VirtualCharSequence chars)
             return false;
         }
 
-        private class MyCodeAction : CodeAction.DocumentChangeAction
+        private class PriorityBasedCodeAction : CodeAction.DocumentChangeAction
         {
             /// <summary>
             /// This is a generally useful feature on strings.  But it's not likely to be something
@@ -186,7 +186,7 @@ private class MyCodeAction : CodeAction.DocumentChangeAction
             /// </summary>
             internal override CodeActionPriority Priority => CodeActionPriority.Low;
 
-            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
+            public PriorityBasedCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument)
                 : base(title, createChangedDocument, title)
             {
             }

diff --git a/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeRefactoringProvider.cs
@@ -55,7 +55,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
 
             var formattingOptions = await document.GetSyntaxFormattingOptionsAsync(context.Options, cancellationToken).ConfigureAwait(false);
 
-            context.RegisterRefactoring(new MyCodeAction(
+            context.RegisterRefactoring(CodeAction.Create(
                 info.Value.title, c => ConvertAsync(document, namespaceDecl, formattingOptions, c), info.Value.equivalenceKey));
         }
 
@@ -72,13 +72,5 @@ private static bool IsValidPosition(BaseNamespaceDeclarationSyntax baseDeclarati
 
             throw ExceptionUtilities.UnexpectedValue(baseDeclaration.Kind());
         }
-
-        private class MyCodeAction : CodeAction.DocumentChangeAction
-        {
-            public MyCodeAction(string title, Func<CancellationToken, Task<Document>> createChangedDocument, string equivalenceKey)
-                : base(title, createChangedDocument, equivalenceKey)
-            {
-            }
-        }
     }
 }
diff --git a/src/Features/CSharp/Portable/ConvertProgram/ConvertToProgramMainCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertProgram/ConvertToProgramMainCodeRefactoringProvider.cs
@@ -56,15 +56,15 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
             if (!CanOfferUseProgramMain(option, root, compilation, forAnalyzer: false))
                 return;
 
-            context.RegisterRefactoring(new MyCodeAction(
+            context.RegisterRefactoring(new PriorityBasedCodeAction(
                 c => ConvertToProgramMainAsync(document, c)));
         }
 
-        private class MyCodeAction : CodeAction.DocumentChangeAction
+        private class PriorityBasedCodeAction : CodeAction.DocumentChangeAction
         {
             internal override CodeActionPriority Priority => CodeActionPriority.Low;
 
-            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
+            public PriorityBasedCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
                 : base(CSharpAnalyzersResources.Convert_to_Program_Main_style_program, createChangedDocument, nameof(ConvertToProgramMainCodeRefactoringProvider))
             {
             }

diff --git a/...ures/CSharp/Portable/ConvertProgram/ConvertToTopLevelStatementsCodeRefactoringProvider.cs b/...ures/CSharp/Portable/ConvertProgram/ConvertToTopLevelStatementsCodeRefactoringProvider.cs
@@ -59,15 +59,15 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte
                 return;
             }
 
-            context.RegisterRefactoring(new MyCodeAction(
+            context.RegisterRefactoring(new PriorityBasedCodeAction(
                 c => ConvertToTopLevelStatementsAsync(document, methodDeclaration, CodeCleanupOptions.CreateProvider(context.Options), c)));
         }
 
-        private class MyCodeAction : CodeAction.DocumentChangeAction
+        private class PriorityBasedCodeAction : CodeAction.DocumentChangeAction
         {
             internal override CodeActionPriority Priority => CodeActionPriority.Low;
 
-            public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
+            public PriorityBasedCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)
                 : base(CSharpAnalyzersResources.Convert_to_top_level_statements, createChangedDocument, nameof(ConvertToTopLevelStatementsCodeRefactoringProvider))
             {
             }