From 23281ba1f8f04a0e4816d785311ea7dc2f09b630 Mon Sep 17 00:00:00 2001 From: Manish Vasani Date: Sun, 1 May 2022 21:54:51 -0700 Subject: [PATCH] Remove all remaining MyCodeAction types in the repo Follow up to #60480 and #60557 --- .../AbstractUnsealClassCodeFixProvider.cs | 13 ++------ .../CodeActions/Preview/PreviewTests.cs | 6 ++-- .../CodeActions/Preview/PreviewTests.vb | 4 +-- ...tractAssignOutParametersCodeFixProvider.cs | 8 ----- ...signOutParametersAtStartCodeFixProvider.cs | 6 +++- ...sionInInterpolatedStringCodeFixProvider.cs | 16 +++------- ...FunctionToMethodCodeRefactoringProvider.cs | 15 +++------ .../EnableNullableCodeRefactoringProvider.cs | 6 ++-- .../InlineTemporaryCodeRefactoringProvider.cs | 13 +++----- .../AbstractUseTypeCodeRefactoringProvider.cs | 13 ++------ ...ecursivePatternsCodeRefactoringProvider.cs | 11 ++----- ...ndVerbatimStringCodeRefactoringProvider.cs | 8 ++--- ...ConvertNamespaceCodeRefactoringProvider.cs | 10 +----- ...ertToProgramMainCodeRefactoringProvider.cs | 6 ++-- ...pLevelStatementsCodeRefactoringProvider.cs | 6 ++-- ...tringToRawStringCodeRefactoringProvider.cs | 10 +++--- ...angeImplementionCodeRefactoringProvider.cs | 26 +++++++-------- .../MakeRefStructCodeFixProvider.cs | 15 +++------ ...emoveUnusedLocalFunctionCodeFixProvider.cs | 15 ++++----- ...arpReplaceDefaultLiteralCodeFixProvider.cs | 13 ++------ ...erseForStatementCodeRefactoringProvider.cs | 15 +++------ .../UseExplicitTypeForConstCodeFixProvider.cs | 15 +++------ ...seExpressionBodyCodeRefactoringProvider.cs | 25 ++++++--------- ...xpressionBodyForLambdaCodeStyleProvider.cs | 8 ----- ...onBodyForLambdaCodeStyleProvider_Fixing.cs | 8 +++-- ...yForLambdaCodeStyleProvider_Refactoring.cs | 10 +++--- ...sAndCastCheckWithoutNameCodeFixProvider.cs | 6 ++-- ...dAnonymousTypeMemberNameCodeFixProvider.cs | 15 ++++----- ...dDebuggerDisplayCodeRefactoringProvider.cs | 6 ++-- ...actAddFileBannerCodeRefactoringProvider.cs | 13 +++----- .../AbstractAddParameterCodeFixProvider.cs | 26 ++++++--------- .../AbstractConvertToAsyncCodeFixProvider.cs | 13 ++------ ...AbstractAddAwaitCodeRefactoringProvider.cs | 18 ++++------- ...actExtractMethodCodeRefactoringProvider.cs | 12 ++----- .../AbstractConflictMarkerCodeFixProvider.cs | 14 ++------ ...ymousTypeToClassCodeRefactoringProvider.cs | 22 ++++++------- ...tractConvertCastCodeRefactoringProvider.cs | 13 ++------ ...vertForToForEachCodeRefactoringProvider.cs | 14 +++----- ...onvertIfToSwitchCodeRefactoringProvider.cs | 14 +++----- ...stractConvertLinqQueryToForEachProvider.cs | 13 ++------ ...rtNumericLiteralCodeRefactoringProvider.cs | 9 +----- ...ToInterpolatedStringRefactoringProvider.cs | 14 +++----- ...ToInterpolatedStringRefactoringProvider.cs | 6 ++-- ...ertTupleToStructCodeRefactoringProvider.cs | 13 +------- ...stractAddDocCommentNodesCodeFixProvider.cs | 14 +++----- ...ractRemoveDocCommentNodeCodeFixProvider.cs | 14 +++----- .../AbstractJsonDetectionCodeFixProvider.cs | 15 ++++----- .../AbstractEncapsulateFieldService.cs | 32 ++++++++----------- .../AbstractFullyQualifyCodeFixProvider.cs | 13 ++------ ...parisonOperatorsCodeRefactoringProvider.cs | 12 ++----- .../AbstractGenerateConstructorService.cs | 23 ++++++------- .../AbstractGenerateVariableService.cs | 13 ++------ .../AbstractGenerateTypeService.cs | 14 +++----- ...ddParameterCheckCodeRefactoringProvider.cs | 8 ++--- ...erCodeRefactoringProviderMemberCreation.cs | 25 +++++++++------ ...tializeParameterCodeRefactoringProvider.cs | 8 ----- ...ceUsingStatementCodeRefactoringProvider.cs | 14 +++----- .../AbstractIntroduceParameterService.cs | 16 +++------- ...calForExpressionCodeRefactoringProvider.cs | 13 ++------ ...nvertConditionalCodeRefactoringProvider.cs | 15 +++------ ...AbstractInvertIfCodeRefactoringProvider.cs | 14 +++----- ...actInvertLogicalCodeRefactoringProvider.cs | 13 ++------ ...ctMakeMethodAsynchronousCodeFixProvider.cs | 20 +++++------- ...actMakeMethodSynchronousCodeFixProvider.cs | 15 +++------ ...ionNearReferenceCodeRefactoringProvider.cs | 6 ++-- ...NameTupleElementCodeRefactoringProvider.cs | 13 ++------ ...tractRemoveAsyncModifierCodeFixProvider.cs | 15 ++++----- ...ractRemoveUnusedVariableCodeFixProvider.cs | 17 +++++----- ...mmentTextWithTagCodeRefactoringProvider.cs | 13 ++------ ...AbstractSimplifyThisOrMeCodeFixProvider.cs | 19 ++++------- ...bstractSimplifyTypeNamesCodeFixProvider.cs | 19 ++++------- .../AbstractSpellCheckCodeFixProvider.cs | 6 ++-- ...tiveIfStatementsCodeRefactoringProvider.cs | 11 ++----- ...tiveIfStatementsCodeRefactoringProvider.cs | 13 +++----- ...stedIfStatementsCodeRefactoringProvider.cs | 11 ++----- ...stedIfStatementsCodeRefactoringProvider.cs | 13 +++----- ...seNamedArgumentsCodeRefactoringProvider.cs | 23 ++++++------- .../GenerateEndConstructCodeFixProvider.vb | 26 +++++++-------- ...orrectFunctionReturnTypeCodeFixProvider.vb | 13 +++----- ...cInlineTemporaryCodeRefactoringProvider.vb | 14 +++----- ...eSharedFromModuleMembersCodeFixProvider.vb | 15 ++++----- ...lRemoveUnnecessaryUsingsCodeFixProvider.cs | 14 +++----- 82 files changed, 369 insertions(+), 745 deletions(-) diff --git a/src/Analyzers/Core/CodeFixes/UnsealClass/AbstractUnsealClassCodeFixProvider.cs b/src/Analyzers/Core/CodeFixes/UnsealClass/AbstractUnsealClassCodeFixProvider.cs index d0f0843212cf1..dd577b3690d79 100644 --- 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 UnsealDeclarationsAsync( return solution; } - - private sealed class MyCodeAction : CustomCodeActions.SolutionChangeAction - { - public MyCodeAction(string title, Func> createChangedSolution) - : base(title, createChangedSolution, title) - { - } - } } } diff --git a/src/EditorFeatures/CSharpTest/CodeActions/Preview/PreviewTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/Preview/PreviewTests.cs index 1991f04438d6a..da7c6f1f51d1e 100644 --- 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 index 1bed912f62928..0f67c6ccd7858 100644 --- 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/src/Features/CSharp/Portable/AssignOutParameters/AbstractAssignOutParametersCodeFixProvider.cs b/src/Features/CSharp/Portable/AssignOutParameters/AbstractAssignOutParametersCodeFixProvider.cs index 7115f93fc94fe..c0f6db0bc86e3 100644 --- a/src/Features/CSharp/Portable/AssignOutParameters/AbstractAssignOutParametersCodeFixProvider.cs +++ b/src/Features/CSharp/Portable/AssignOutParameters/AbstractAssignOutParametersCodeFixProvider.cs @@ -165,13 +165,5 @@ protected static ImmutableArray GenerateAssignmentStatements( return result.ToImmutableAndFree(); } - - protected class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/CSharp/Portable/AssignOutParameters/AssignOutParametersAtStartCodeFixProvider.cs b/src/Features/CSharp/Portable/AssignOutParameters/AssignOutParametersAtStartCodeFixProvider.cs index 94c3e91b87e78..2f78ec398d8c5 100644 --- a/src/Features/CSharp/Portable/AssignOutParameters/AssignOutParametersAtStartCodeFixProvider.cs +++ b/src/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/src/Features/CSharp/Portable/CodeFixes/ConditionalExpressionInStringInterpolation/CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs b/src/Features/CSharp/Portable/CodeFixes/ConditionalExpressionInStringInterpolation/CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs index 2477f7b27e3ed..a2b23bfbc8af4 100644 --- a/src/Features/CSharp/Portable/CodeFixes/ConditionalExpressionInStringInterpolation/CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs +++ b/src/Features/CSharp/Portable/CodeFixes/ConditionalExpressionInStringInterpolation/CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProvider.cs @@ -43,8 +43,10 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) var conditionalExpression = token.GetAncestor(); 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 InsertCloseParenthesisAsync( var newRoot = root.ReplaceNode(parenthesizedExpression, parenthesizedExpressionWithClosingParen); return document.WithSyntaxRoot(newRoot); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(CSharpFeaturesResources.Add_parentheses_around_conditional_expression_in_interpolated_string, - createChangedDocument, - CSharpFeaturesResources.Add_parentheses_around_conditional_expression_in_interpolated_string) - { - } - } } } diff --git a/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs index d0e16360066bf..527917aaadcd8 100644 --- a/src/Features/CSharp/Portable/CodeRefactorings/ConvertLocalFunctionToMethod/CSharpConvertLocalFunctionToMethodCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/CodeRefactorings/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> createChangedDocument) - : base(CSharpFeaturesResources.Convert_to_method, createChangedDocument, nameof(CSharpFeaturesResources.Convert_to_method)) - { - } - } } } diff --git a/src/Features/CSharp/Portable/CodeRefactorings/EnableNullable/EnableNullableCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/EnableNullable/EnableNullableCodeRefactoringProvider.cs index 706522c837a47..7d79b413f7714 100644 --- a/src/Features/CSharp/Portable/CodeRefactorings/EnableNullable/EnableNullableCodeRefactoringProvider.cs +++ b/src/Features/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 CustomCodeAction((purpose, cancellationToken) => EnableNullableReferenceTypesAsync(document.Project, purpose, cancellationToken))); } private static async Task EnableNullableReferenceTypesAsync(Project project, CodeActionPurpose purpose, CancellationToken cancellationToken) @@ -252,11 +252,11 @@ private enum CodeActionPurpose Apply, } - private sealed class MyCodeAction : CodeAction.SolutionChangeAction + private sealed class CustomCodeAction : CodeAction.SolutionChangeAction { private readonly Func> _createChangedSolution; - public MyCodeAction(Func> createChangedSolution) + public CustomCodeAction(Func> createChangedSolution) : base( CSharpFeaturesResources.Enable_nullable_reference_types_in_project, cancellationToken => createChangedSolution(CodeActionPurpose.Apply, cancellationToken), diff --git a/src/Features/CSharp/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.cs index b29730693a352..ba30e2cacd2ff 100644 --- a/src/Features/CSharp/Portable/CodeRefactorings/InlineTemporary/InlineTemporaryCodeRefactoringProvider.cs +++ b/src/Features/CSharp/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> createChangedDocument) - : base(CSharpFeaturesResources.Inline_temporary_variable, createChangedDocument, nameof(CSharpFeaturesResources.Inline_temporary_variable)) - { - } - } } } diff --git a/src/Features/CSharp/Portable/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs index c4fc06cc4234e..cb509f7573520 100644 --- a/src/Features/CSharp/Portable/CodeRefactorings/UseExplicitOrImplicitType/AbstractUseTypeCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/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 UpdateDocumentAsync(Document document, TypeSyntax t var newRoot = editor.GetChangedRoot(); return document.WithSyntaxRoot(newRoot); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/CSharp/Portable/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs index 74bae4627819c..3f3a371d406e5 100644 --- a/src/Features/CSharp/Portable/CodeRefactorings/UseRecursivePatterns/UseRecursivePatternsCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/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> createChangedDocument, string equivalenceKey) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/CSharp/Portable/ConvertBetweenRegularAndVerbatimString/AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertBetweenRegularAndVerbatimString/AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs index fae50a6885574..3f5f210f4131d 100644 --- a/src/Features/CSharp/Portable/ConvertBetweenRegularAndVerbatimString/AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertBetweenRegularAndVerbatimString/AbstractConvertBetweenRegularAndVerbatimStringCodeRefactoringProvider.cs @@ -56,7 +56,7 @@ 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))); } @@ -64,7 +64,7 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex { // 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 { /// /// 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 /// internal override CodeActionPriority Priority => CodeActionPriority.Low; - public MyCodeAction(string title, Func> createChangedDocument) + public PriorityBasedCodeAction(string title, Func> createChangedDocument) : base(title, createChangedDocument, title) { } diff --git a/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertNamespace/ConvertNamespaceCodeRefactoringProvider.cs index 2acc1e04063e5..3c178f167981c 100644 --- 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> 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 index 1c496722902cc..80cfba1975e29 100644 --- 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> createChangedDocument) + public PriorityBasedCodeAction(Func> createChangedDocument) : base(CSharpAnalyzersResources.Convert_to_Program_Main_style_program, createChangedDocument, nameof(ConvertToProgramMainCodeRefactoringProvider)) { } diff --git a/src/Features/CSharp/Portable/ConvertProgram/ConvertToTopLevelStatementsCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertProgram/ConvertToTopLevelStatementsCodeRefactoringProvider.cs index 843957b96f647..b41d0ceac8e6e 100644 --- a/src/Features/CSharp/Portable/ConvertProgram/ConvertToTopLevelStatementsCodeRefactoringProvider.cs +++ b/src/Features/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> createChangedDocument) + public PriorityBasedCodeAction(Func> createChangedDocument) : base(CSharpAnalyzersResources.Convert_to_top_level_statements, createChangedDocument, nameof(ConvertToTopLevelStatementsCodeRefactoringProvider)) { } diff --git a/src/Features/CSharp/Portable/ConvertToRawString/ConvertRegularStringToRawStringCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ConvertToRawString/ConvertRegularStringToRawStringCodeRefactoringProvider.cs index 168442c938f9e..8133afcdb04e4 100644 --- a/src/Features/CSharp/Portable/ConvertToRawString/ConvertRegularStringToRawStringCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ConvertToRawString/ConvertRegularStringToRawStringCodeRefactoringProvider.cs @@ -82,7 +82,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte if (canBeSingleLine) { context.RegisterRefactoring( - new MyCodeAction( + new PriorityBasedCodeAction( CSharpFeaturesResources.Convert_to_raw_string, c => UpdateDocumentAsync(document, span, ConvertToRawKind.SingleLine, formattingOptions, c), nameof(CSharpFeaturesResources.Convert_to_raw_string) + "-" + ConvertToRawKind.SingleLine, @@ -92,7 +92,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte else { context.RegisterRefactoring( - new MyCodeAction( + new PriorityBasedCodeAction( CSharpFeaturesResources.Convert_to_raw_string, c => UpdateDocumentAsync(document, span, ConvertToRawKind.MultiLineIndented, formattingOptions, c), nameof(CSharpFeaturesResources.Convert_to_raw_string), @@ -128,7 +128,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte CleanupWhitespace(characters).Length > 0) { context.RegisterRefactoring( - new MyCodeAction( + new PriorityBasedCodeAction( CSharpFeaturesResources.without_leading_whitespace_may_change_semantics, c => UpdateDocumentAsync(document, span, ConvertToRawKind.MultiLineWithoutLeadingWhitespace, formattingOptions, c), nameof(CSharpFeaturesResources.without_leading_whitespace_may_change_semantics), @@ -377,11 +377,11 @@ private static SyntaxToken ConvertToSingleLineRawString( token.TrailingTrivia); } - private class MyCodeAction : CodeAction.DocumentChangeAction + private class PriorityBasedCodeAction : CodeAction.DocumentChangeAction { internal override CodeActionPriority Priority { get; } - public MyCodeAction( + public PriorityBasedCodeAction( string title, Func> createChangedDocument, string equivalenceKey, diff --git a/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs index 8ec4133700b49..73c895ade88a6 100644 --- a/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ImplementInterface/AbstractChangeImplementionCodeRefactoringProvider.cs @@ -71,9 +71,11 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex // like: "System.IEnumerable.GetEnumerator" directlyImplementedMembers.AddRange(member, member.ExplicitOrImplicitInterfaceImplementations()); - var codeAction = new MyCodeAction( - string.Format(Implement_0, member.ExplicitOrImplicitInterfaceImplementations().First().Name), - c => ChangeImplementationAsync(project, directlyImplementedMembers, c)); + var firstImplName = member.ExplicitOrImplicitInterfaceImplementations().First().Name; + var codeAction = CodeAction.Create( + string.Format(Implement_0, firstImplName), + c => ChangeImplementationAsync(project, directlyImplementedMembers, c), + nameof(Implement_0) + firstImplName); var containingType = member.ContainingType; var interfaceTypes = directlyImplementedMembers.SelectMany(kvp => kvp.Value).Select( @@ -102,16 +104,18 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex if (offerForSameInterface) { var interfaceNames = interfaceTypes.Select(i => i.ToDisplayString(NameAndTypeParametersFormat)); - nestedActions.Add(new MyCodeAction( + nestedActions.Add(CodeAction.Create( string.Format(Implement_0, string.Join(", ", interfaceNames)), - c => ChangeImplementationAsync(project, implementedMembersFromSameInterfaces, c))); + c => ChangeImplementationAsync(project, implementedMembersFromSameInterfaces, c), + nameof(Implement_0) + string.Join(", ", interfaceNames))); } if (offerForAllInterfaces) { - nestedActions.Add(new MyCodeAction( + nestedActions.Add(CodeAction.Create( Implement_all_interfaces, - c => ChangeImplementationAsync(project, implementedMembersFromAllInterfaces, c))); + c => ChangeImplementationAsync(project, implementedMembersFromAllInterfaces, c), + nameof(Implement_all_interfaces))); } context.RegisterRefactoring(CodeAction.CodeActionWithNestedActions.Create( @@ -246,13 +250,5 @@ await UpdateReferencesAsync( return solutionEditor.GetChangedSolution(); } - - private class MyCodeAction : CodeAction.SolutionChangeAction - { - public MyCodeAction(string title, Func> createChangedSolution) - : base(title, createChangedSolution, title) - { - } - } } } diff --git a/src/Features/CSharp/Portable/MakeRefStruct/MakeRefStructCodeFixProvider.cs b/src/Features/CSharp/Portable/MakeRefStruct/MakeRefStructCodeFixProvider.cs index 6f369efb27879..6ef817fa34ff3 100644 --- a/src/Features/CSharp/Portable/MakeRefStruct/MakeRefStructCodeFixProvider.cs +++ b/src/Features/CSharp/Portable/MakeRefStruct/MakeRefStructCodeFixProvider.cs @@ -55,7 +55,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) if (!structDeclarationSymbol.IsRefLikeType) { context.RegisterCodeFix( - new MyCodeAction(c => FixCodeAsync(document, structDeclaration, c)), + CodeAction.Create( + CSharpFeaturesResources.Make_ref_struct, + c => FixCodeAsync(document, structDeclaration, c), + nameof(CSharpFeaturesResources.Make_ref_struct)), context.Diagnostics); } } @@ -89,15 +92,5 @@ private static StructDeclarationSyntax FindContainingStruct(SyntaxNode root, Tex // so find only the first parent declaration return member.GetAncestor() as StructDeclarationSyntax; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(CSharpFeaturesResources.Make_ref_struct, - createChangedDocument, - CSharpFeaturesResources.Make_ref_struct) - { - } - } } } diff --git a/src/Features/CSharp/Portable/RemoveUnusedLocalFunction/CSharpRemoveUnusedLocalFunctionCodeFixProvider.cs b/src/Features/CSharp/Portable/RemoveUnusedLocalFunction/CSharpRemoveUnusedLocalFunctionCodeFixProvider.cs index 000bda31cd5f1..c22b3b2671e2f 100644 --- a/src/Features/CSharp/Portable/RemoveUnusedLocalFunction/CSharpRemoveUnusedLocalFunctionCodeFixProvider.cs +++ b/src/Features/CSharp/Portable/RemoveUnusedLocalFunction/CSharpRemoveUnusedLocalFunctionCodeFixProvider.cs @@ -38,7 +38,12 @@ public sealed override ImmutableArray FixableDiagnosticIds public override Task RegisterCodeFixesAsync(CodeFixContext context) { - context.RegisterCodeFix(new MyCodeAction(GetDocumentUpdater(context)), context.Diagnostics); + context.RegisterCodeFix( + CodeAction.Create( + CSharpFeaturesResources.Remove_unused_function, + GetDocumentUpdater(context), + nameof(CSharpFeaturesResources.Remove_unused_function)), + context.Diagnostics); return Task.CompletedTask; } @@ -61,13 +66,5 @@ protected override Task FixAllAsync(Document document, ImmutableArray> createChangedDocument) - : base(CSharpFeaturesResources.Remove_unused_function, createChangedDocument, CSharpFeaturesResources.Remove_unused_function) - { - } - } } } diff --git a/src/Features/CSharp/Portable/ReplaceDefaultLiteral/CSharpReplaceDefaultLiteralCodeFixProvider.cs b/src/Features/CSharp/Portable/ReplaceDefaultLiteral/CSharpReplaceDefaultLiteralCodeFixProvider.cs index f69765df6e698..441f14f7a164a 100644 --- a/src/Features/CSharp/Portable/ReplaceDefaultLiteral/CSharpReplaceDefaultLiteralCodeFixProvider.cs +++ b/src/Features/CSharp/Portable/ReplaceDefaultLiteral/CSharpReplaceDefaultLiteralCodeFixProvider.cs @@ -59,9 +59,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) if (newExpression != null) { context.RegisterCodeFix( - new MyCodeAction( + CodeAction.Create( + string.Format(CSharpFeaturesResources.Use_0, displayText), c => ReplaceAsync(context.Document, context.Span, newExpression, c), - displayText), + nameof(CSharpFeaturesResources.Use_0) + displayText), context.Diagnostics); } } @@ -148,13 +149,5 @@ private static bool IsZero(object o) return false; } } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument, string literal) - : base(string.Format(CSharpFeaturesResources.Use_0, literal), createChangedDocument, CSharpFeaturesResources.Use_0) - { - } - } } } diff --git a/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs index 9a8c32a78477c..b8aaf6a03e895 100644 --- a/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/ReverseForStatement/CSharpReverseForStatementCodeRefactoringProvider.cs @@ -74,8 +74,11 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte return; } - context.RegisterRefactoring(new MyCodeAction( - c => ReverseForStatementAsync(document, forStatement, c))); + context.RegisterRefactoring( + CodeAction.Create( + CSharpFeaturesResources.Reverse_for_statement, + c => ReverseForStatementAsync(document, forStatement, c), + nameof(CSharpFeaturesResources.Reverse_for_statement))); } } @@ -392,13 +395,5 @@ private static ExpressionSyntax InvertAfter(ExpressionSyntax after) var newOpToken = SyntaxFactory.Token(newKind).WithTriviaFrom(opToken); return after.ReplaceToken(opToken, newOpToken); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(CSharpFeaturesResources.Reverse_for_statement, createChangedDocument, nameof(CSharpFeaturesResources.Reverse_for_statement)) - { - } - } } } diff --git a/src/Features/CSharp/Portable/UseExplicitTypeForConst/UseExplicitTypeForConstCodeFixProvider.cs b/src/Features/CSharp/Portable/UseExplicitTypeForConst/UseExplicitTypeForConstCodeFixProvider.cs index 5bd37b9bada53..da6e2459a1dc6 100644 --- a/src/Features/CSharp/Portable/UseExplicitTypeForConst/UseExplicitTypeForConstCodeFixProvider.cs +++ b/src/Features/CSharp/Portable/UseExplicitTypeForConst/UseExplicitTypeForConstCodeFixProvider.cs @@ -53,7 +53,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) } context.RegisterCodeFix( - new MyCodeAction(c => FixAsync(context.Document, context.Span, type, c)), + CodeAction.Create( + CSharpAnalyzersResources.Use_explicit_type_instead_of_var, + c => FixAsync(context.Document, context.Span, type, c), + nameof(CSharpAnalyzersResources.Use_explicit_type_instead_of_var)), context.Diagnostics); } } @@ -67,15 +70,5 @@ private static async Task FixAsync( var newRoot = root.ReplaceNode(variableDeclaration.Type, type.GenerateTypeSyntax(allowVar: false)); return document.WithSyntaxRoot(newRoot); } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(CSharpAnalyzersResources.Use_explicit_type_instead_of_var, - createChangedDocument, - nameof(CSharpAnalyzersResources.Use_explicit_type_instead_of_var)) - { - } - } } } diff --git a/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs b/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs index 7c18d147aada6..ddb97453aaf1c 100644 --- a/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs +++ b/src/Features/CSharp/Portable/UseExpressionBody/UseExpressionBodyCodeRefactoringProvider.cs @@ -97,11 +97,13 @@ private static bool TryComputeRefactoring( var succeeded = false; if (helper.CanOfferUseExpressionBody(optionSet, declaration, forAnalyzer: false)) { - context.RegisterRefactoring(new MyCodeAction( - helper.UseExpressionBodyTitle.ToString(), - c => UpdateDocumentAsync( - document, root, declaration, helper, - useExpressionBody: true, cancellationToken: c)), + context.RegisterRefactoring( + CodeAction.Create( + helper.UseExpressionBodyTitle.ToString(), + c => UpdateDocumentAsync( + document, root, declaration, helper, + useExpressionBody: true, cancellationToken: c), + nameof(helper.UseExpressionBodyTitle)), declaration.Span); succeeded = true; } @@ -109,11 +111,12 @@ private static bool TryComputeRefactoring( if (helper.CanOfferUseBlockBody(optionSet, declaration, forAnalyzer: false, out _, out _)) { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( helper.UseBlockBodyTitle.ToString(), c => UpdateDocumentAsync( document, root, declaration, helper, - useExpressionBody: false, cancellationToken: c)), + useExpressionBody: false, cancellationToken: c), + nameof(helper.UseBlockBodyTitle)), declaration.Span); succeeded = true; } @@ -150,13 +153,5 @@ private static async Task UpdateDocumentAsync( var newRoot = root.ReplaceNode(parent, updatedParent); return document.WithSyntaxRoot(newRoot); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs index 0357333fdb241..8dc2edf4352dc 100644 --- a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs +++ b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider.cs @@ -214,14 +214,6 @@ private static bool CreateReturnStatementForExpression( return true; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } // Stub classes needed only for exporting purposes. diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Fixing.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Fixing.cs index 3fb7b6c768d0c..9f451b3cb3d49 100644 --- a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Fixing.cs +++ b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Fixing.cs @@ -20,9 +20,11 @@ internal partial class UseExpressionBodyForLambdaCodeStyleProvider { protected override Task> ComputeCodeActionsAsync(Document document, Diagnostic diagnostic, CancellationToken cancellationToken) { - var codeAction = new MyCodeAction( - diagnostic.GetMessage(), - c => FixWithSyntaxEditorAsync(document, diagnostic, c)); + var title = diagnostic.GetMessage(); + var codeAction = CodeAction.Create( + title, + c => FixWithSyntaxEditorAsync(document, diagnostic, c), + title); return Task.FromResult(ImmutableArray.Create(codeAction)); } diff --git a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs index a394bfb30fe7b..9778c9806549c 100644 --- a/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs +++ b/src/Features/CSharp/Portable/UseExpressionBodyForLambda/UseExpressionBodyForLambdaCodeStyleProvider_Refactoring.cs @@ -109,19 +109,21 @@ private static async Task> ComputeRefactoringsAsync( using var resultDisposer = ArrayBuilder.GetInstance(out var result); if (CanOfferUseExpressionBody(option, lambdaNode, root.GetLanguageVersion())) { - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( UseExpressionBodyTitle.ToString(), c => UpdateDocumentAsync( - document, root, lambdaNode, c))); + document, root, lambdaNode, c), + nameof(UseExpressionBodyTitle))); } var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); if (CanOfferUseBlockBody(semanticModel, option, lambdaNode, cancellationToken)) { - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( UseBlockBodyTitle.ToString(), c => UpdateDocumentAsync( - document, root, lambdaNode, c))); + document, root, lambdaNode, c), + nameof(UseBlockBodyTitle))); } return result.ToImmutable(); diff --git a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs index de74dc3ca8dea..8723f25d75d86 100644 --- a/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs +++ b/src/Features/CSharp/Portable/UsePatternMatching/CSharpIsAndCastCheckWithoutNameCodeFixProvider.cs @@ -37,7 +37,7 @@ public override ImmutableArray FixableDiagnosticIds public override Task RegisterCodeFixesAsync(CodeFixContext context) { - context.RegisterCodeFix(new MyCodeAction(GetDocumentUpdater(context)), context.Diagnostics); + context.RegisterCodeFix(new PriorityBasedCodeAction(GetDocumentUpdater(context)), context.Diagnostics); return Task.CompletedTask; } @@ -63,9 +63,9 @@ protected override async Task FixAllAsync( editor.ReplaceNode(editor.OriginalRoot, updatedRoot); } - private class MyCodeAction : CodeAction.DocumentChangeAction + private class PriorityBasedCodeAction : CodeAction.DocumentChangeAction { - public MyCodeAction(Func> createChangedDocument) + public PriorityBasedCodeAction(Func> createChangedDocument) : base(CSharpAnalyzersResources.Use_pattern_matching, createChangedDocument, nameof(CSharpIsAndCastCheckWithoutNameCodeFixProvider)) { } diff --git a/src/Features/Core/Portable/AddAnonymousTypeMemberName/AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs b/src/Features/Core/Portable/AddAnonymousTypeMemberName/AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs index 0ce53cfa86f30..bb4a326124f06 100644 --- a/src/Features/Core/Portable/AddAnonymousTypeMemberName/AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs +++ b/src/Features/Core/Portable/AddAnonymousTypeMemberName/AbstractAddAnonymousTypeMemberNameCodeFixProvider.cs @@ -42,7 +42,12 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) return; } - context.RegisterCodeFix(new MyCodeAction(GetDocumentUpdater(context)), context.Diagnostics); + context.RegisterCodeFix( + CodeAction.Create( + FeaturesResources.Add_member_name, + GetDocumentUpdater(context), + nameof(FeaturesResources.Add_member_name)), + context.Diagnostics); } private async Task GetMemberDeclaratorAsync( @@ -129,13 +134,5 @@ private async Task FixOneAsync( return WithName(currentDeclarator, nameToken); }); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Add_member_name, createChangedDocument, nameof(FeaturesResources.Add_member_name)) - { - } - } } } diff --git a/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs b/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs index 261c20b40f164..9f246b3d4202d 100644 --- a/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/AddDebuggerDisplay/AbstractAddDebuggerDisplayCodeRefactoringProvider.cs @@ -56,7 +56,7 @@ await GetRelevantTypeFromHeaderAsync(context).ConfigureAwait(false) ?? if (HasDebuggerDisplayAttribute(typeSymbol, compilation)) return; - context.RegisterRefactoring(new MyCodeAction( + context.RegisterRefactoring(new PriorityBasedCodeAction( priority, c => ApplyAsync(document, type, debuggerAttributeTypeSymbol, c))); } @@ -175,11 +175,11 @@ private async Task ApplyAsync(Document document, TTypeDeclarationSynta return document.WithSyntaxRoot(editor.GetChangedRoot()); } - private sealed class MyCodeAction : CodeAction.DocumentChangeAction + private sealed class PriorityBasedCodeAction : CodeAction.DocumentChangeAction { internal override CodeActionPriority Priority { get; } - public MyCodeAction(CodeActionPriority priority, Func> createChangedDocument) + public PriorityBasedCodeAction(CodeActionPriority priority, Func> createChangedDocument) : base(FeaturesResources.Add_DebuggerDisplay_attribute, createChangedDocument, nameof(FeaturesResources.Add_DebuggerDisplay_attribute)) { Priority = priority; diff --git a/src/Features/Core/Portable/AddFileBanner/AbstractAddFileBannerCodeRefactoringProvider.cs b/src/Features/Core/Portable/AddFileBanner/AbstractAddFileBannerCodeRefactoringProvider.cs index 5744c0ab94899..abea0ab575aea 100644 --- a/src/Features/Core/Portable/AddFileBanner/AbstractAddFileBannerCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/AddFileBanner/AbstractAddFileBannerCodeRefactoringProvider.cs @@ -82,7 +82,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte if (siblingBanner.Length > 0 && !siblingDocument.IsGeneratedCode(cancellationToken)) { context.RegisterRefactoring( - new MyCodeAction(_ => AddBannerAsync(document, root, siblingDocument, siblingBanner)), + CodeAction.Create( + CodeFixesResources.Add_file_header, + _ => AddBannerAsync(document, root, siblingDocument, siblingBanner), + nameof(CodeFixesResources.Add_file_header)), new Text.TextSpan(position, length: 0)); return; } @@ -148,13 +151,5 @@ private async Task> TryGetBannerAsync( var token = syntaxFacts.ParseToken(text.ToString()); return bannerService.GetFileBanner(token); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(CodeFixesResources.Add_file_header, createChangedDocument, nameof(CodeFixesResources.Add_file_header)) - { - } - } } } diff --git a/src/Features/Core/Portable/AddParameter/AbstractAddParameterCodeFixProvider.cs b/src/Features/Core/Portable/AddParameter/AbstractAddParameterCodeFixProvider.cs index f1cb798cc20ef..aaaf7caa5a9fc 100644 --- a/src/Features/Core/Portable/AddParameter/AbstractAddParameterCodeFixProvider.cs +++ b/src/Features/Core/Portable/AddParameter/AbstractAddParameterCodeFixProvider.cs @@ -247,9 +247,10 @@ ImmutableArray NestByOverload() { // We create the mandatory data.CreateChangedSolutionNonCascading fix first. var title = GetCodeFixTitle(FeaturesResources.Add_parameter_to_0, data.Method, includeParameters: true); - CodeAction codeAction = new MyCodeAction( - title: title, - data.CreateChangedSolutionNonCascading); + var codeAction = CodeAction.Create( + title, + data.CreateChangedSolutionNonCascading, + equivalenceKey: title); if (data.CreateChangedSolutionCascading != null) { // We have two fixes to offer. We nest the two fixes in an inlinable CodeAction @@ -261,9 +262,10 @@ ImmutableArray NestByOverload() title: titleForNesting, ImmutableArray.Create( codeAction, - new MyCodeAction( - title: titleCascading, - data.CreateChangedSolutionCascading)), + CodeAction.Create( + titleCascading, + data.CreateChangedSolutionCascading, + equivalenceKey: titleCascading)), isInlinable: true); } @@ -281,7 +283,7 @@ ImmutableArray NestByCascading() var nonCascadingActions = codeFixData.SelectAsArray(data => { var title = GetCodeFixTitle(FeaturesResources.Add_to_0, data.Method, includeParameters: true); - return (CodeAction)new MyCodeAction(title: title, data.CreateChangedSolutionNonCascading); + return CodeAction.Create(title, data.CreateChangedSolutionNonCascading, equivalenceKey: title); }); var cascadingActions = codeFixData.SelectAsArray( @@ -289,7 +291,7 @@ ImmutableArray NestByCascading() data => { var title = GetCodeFixTitle(FeaturesResources.Add_to_0, data.Method, includeParameters: true); - return (CodeAction)new MyCodeAction(title: title, data.CreateChangedSolutionCascading!); + return CodeAction.Create(title, data.CreateChangedSolutionCascading!, equivalenceKey: title); }); var aMethod = codeFixData.First().Method; // We need to term the MethodGroup and need an arbitrary IMethodSymbol to do so. @@ -561,13 +563,5 @@ private static bool TypeInfoMatchesType( return false; } - - private class MyCodeAction : CodeAction.SolutionChangeAction - { - public MyCodeAction(string title, Func> createChangedSolution) - : base(title, createChangedSolution, title) - { - } - } } } diff --git a/src/Features/Core/Portable/CodeFixes/Async/AbstractConvertToAsyncCodeFixProvider.cs b/src/Features/Core/Portable/CodeFixes/Async/AbstractConvertToAsyncCodeFixProvider.cs index 580708ca66e13..e98b8e9bd04e9 100644 --- a/src/Features/Core/Portable/CodeFixes/Async/AbstractConvertToAsyncCodeFixProvider.cs +++ b/src/Features/Core/Portable/CodeFixes/Async/AbstractConvertToAsyncCodeFixProvider.cs @@ -69,17 +69,10 @@ private async Task GetCodeActionAsync( var syntaxTree = result.Item1; var newRoot = result.Item2; var otherDocument = document.Project.Solution.GetDocument(syntaxTree); - return new MyCodeAction( + return CodeAction.Create( await GetDescriptionAsync(diagnostic, node, semanticModel, cancellationToken).ConfigureAwait(false), - token => Task.FromResult(otherDocument.WithSyntaxRoot(newRoot))); - } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } + token => Task.FromResult(otherDocument.WithSyntaxRoot(newRoot)), + nameof(AbstractConvertToAsyncCodeFixProvider)); } } } diff --git a/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs b/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs index a7c7c87ae31f5..054261477a90f 100644 --- a/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/CodeRefactorings/AddAwait/AbstractAddAwaitCodeRefactoringProvider.cs @@ -49,15 +49,17 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex if (IsValidAwaitableExpression(model, syntaxFacts, expression, cancellationToken)) { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( GetTitle(), - c => AddAwaitAsync(document, expression, withConfigureAwait: false, c)), + c => AddAwaitAsync(document, expression, withConfigureAwait: false, c), + equivalenceKey: nameof(GetTitle)), expression.Span); context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( GetTitleWithConfigureAwait(), - c => AddAwaitAsync(document, expression, withConfigureAwait: true, c)), + c => AddAwaitAsync(document, expression, withConfigureAwait: true, c), + equivalenceKey: nameof(GetTitleWithConfigureAwait)), expression.Span); } } @@ -109,13 +111,5 @@ private static Task AddAwaitAsync( return document.ReplaceNodeAsync(expression, awaitExpression, cancellationToken); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs b/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs index d0e83a3ca20f7..80f7748df3d9d 100644 --- a/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/CodeRefactorings/ExtractMethod/AbstractExtractMethodCodeRefactoringProvider.cs @@ -95,7 +95,7 @@ private static async Task ExtractMethodAsync(Document document, Text if (!result.Succeeded && !result.SucceededWithSuggestion) return null; - return new MyCodeAction( + return CodeAction.Create( FeaturesResources.Extract_method, async c => { @@ -124,7 +124,7 @@ private static async Task ExtractLocalFunctionAsync(Document documen if (localFunctionResult.Succeeded || localFunctionResult.SucceededWithSuggestion) { - var codeAction = new MyCodeAction( + var codeAction = CodeAction.Create( FeaturesResources.Extract_local_function, async c => { @@ -148,13 +148,5 @@ private static async Task AddRenameAnnotationAsync(Document document, return document.WithSyntaxRoot(finalRoot); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument, string equivalenceKey) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/ConflictMarkerResolution/AbstractConflictMarkerCodeFixProvider.cs b/src/Features/Core/Portable/ConflictMarkerResolution/AbstractConflictMarkerCodeFixProvider.cs index bcbbdbfee6a5c..cb645fd163608 100644 --- a/src/Features/Core/Portable/ConflictMarkerResolution/AbstractConflictMarkerCodeFixProvider.cs +++ b/src/Features/Core/Portable/ConflictMarkerResolution/AbstractConflictMarkerCodeFixProvider.cs @@ -212,17 +212,17 @@ private static void RegisterCodeFixes( var endPos = endLine.Start; context.RegisterCodeFix( - new MyCodeAction(takeTopText, + CodeAction.Create(takeTopText, c => TakeTopAsync(document, startPos, equalsPos, endPos, c), TakeTopEquivalenceKey), context.Diagnostics); context.RegisterCodeFix( - new MyCodeAction(takeBottomText, + CodeAction.Create(takeBottomText, c => TakeBottomAsync(document, startPos, equalsPos, endPos, c), TakeBottomEquivalenceKey), context.Diagnostics); context.RegisterCodeFix( - new MyCodeAction(FeaturesResources.Take_both, + CodeAction.Create(FeaturesResources.Take_both, c => TakeBothAsync(document, startPos, equalsPos, endPos, c), TakeBothEquivalenceKey), context.Diagnostics); @@ -357,13 +357,5 @@ TakeBottomEquivalenceKey or public override FixAllProvider GetFixAllProvider() => FixAllProvider.Create(async (context, document, diagnostics) => await this.FixAllAsync(document, diagnostics, context.CodeActionEquivalenceKey, context.CancellationToken).ConfigureAwait(false)); - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument, string equivalenceKey) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs index 94a1822ea3e89..88693e32b514b 100644 --- a/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertAnonymousType/AbstractConvertAnonymousTypeToClassCodeRefactoringProvider.cs @@ -61,15 +61,19 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte var syntaxFacts = document.GetRequiredLanguageService(); if (syntaxFacts.SupportsRecord(anonymousObject.SyntaxTree.Options)) { - context.RegisterRefactoring(new MyCodeAction( - FeaturesResources.Convert_to_record, - c => ConvertAsync(document, textSpan, isRecord: true, c)), + context.RegisterRefactoring( + CodeAction.Create( + FeaturesResources.Convert_to_record, + c => ConvertAsync(document, textSpan, isRecord: true, c), + nameof(FeaturesResources.Convert_to_record)), anonymousObject.Span); } - context.RegisterRefactoring(new MyCodeAction( + context.RegisterRefactoring( + CodeAction.Create( FeaturesResources.Convert_to_class, - c => ConvertAsync(document, textSpan, isRecord: false, c)), + c => ConvertAsync(document, textSpan, isRecord: false, c), + nameof(FeaturesResources.Convert_to_class)), anonymousObject.Span); } @@ -400,13 +404,5 @@ private static IMethodSymbol CreateClassConstructor( return constructor; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertCast/AbstractConvertCastCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertCast/AbstractConvertCastCodeRefactoringProvider.cs index 1b54800fb112a..a7b75420b286e 100644 --- a/src/Features/Core/Portable/ConvertCast/AbstractConvertCastCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertCast/AbstractConvertCastCodeRefactoringProvider.cs @@ -51,9 +51,10 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex if (type is { TypeKind: not TypeKind.Error, IsReferenceType: true }) { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( GetTitle(), - c => ConvertAsync(document, from, cancellationToken)), + c => ConvertAsync(document, from, cancellationToken), + nameof(GetTitle)), from.Span); } } @@ -67,13 +68,5 @@ protected async Task ConvertAsync( var newRoot = root.ReplaceNode(from, ConvertExpression(from)); return document.WithSyntaxRoot(newRoot); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertForToForEach/AbstractConvertForToForEachCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertForToForEach/AbstractConvertForToForEachCodeRefactoringProvider.cs index 79b78d79d3c06..ed5155aaae264 100644 --- a/src/Features/Core/Portable/ConvertForToForEach/AbstractConvertForToForEachCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertForToForEach/AbstractConvertForToForEachCodeRefactoringProvider.cs @@ -147,10 +147,12 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte // Looks good. We can convert this. context.RegisterRefactoring( - new MyCodeAction(GetTitle(), + CodeAction.Create( + GetTitle(), c => ConvertForToForEachAsync( document, forStatement, iterationVariable, collectionExpression, - containingType, collectionType.Type, iterationType, c)), + containingType, collectionType.Type, iterationType, c), + nameof(GetTitle)), forStatement.Span); return; @@ -494,13 +496,5 @@ private static bool IsViableIndexer(IPropertySymbol property) => property.IsIndexer && property.Parameters.Length == 1 && property.Parameters[0].Type?.SpecialType == SpecialType.System_Int32; - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertIfToSwitch/AbstractConvertIfToSwitchCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertIfToSwitch/AbstractConvertIfToSwitchCodeRefactoringProvider.cs index 56b6cbd0b2c75..13f9da40d2ee7 100644 --- a/src/Features/Core/Portable/ConvertIfToSwitch/AbstractConvertIfToSwitchCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertIfToSwitch/AbstractConvertIfToSwitchCodeRefactoringProvider.cs @@ -78,7 +78,8 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex } context.RegisterRefactoring( - new MyCodeAction(GetTitle(forSwitchExpression: false), + CodeAction.Create( + GetTitle(forSwitchExpression: false), c => UpdateDocumentAsync(document, target, ifStatement, sections, analyzer.Features, convertToSwitchExpression: false, c), "SwitchStatement"), ifStatement.Span); @@ -87,7 +88,8 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex CanConvertToSwitchExpression(analyzer.Supports(Feature.OrPattern), sections)) { context.RegisterRefactoring( - new MyCodeAction(GetTitle(forSwitchExpression: true), + CodeAction.Create( + GetTitle(forSwitchExpression: true), c => UpdateDocumentAsync(document, target, ifStatement, sections, analyzer.Features, convertToSwitchExpression: true, c), "SwitchExpression"), ifStatement.Span); @@ -150,13 +152,5 @@ static bool CanConvertSectionForSwitchExpression(bool supportsOrPattern, Analyze return supportsOrPattern && section.Labels.All(label => label.Guards.IsDefaultOrEmpty); } } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument, string equivalenceKey) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertLinq/AbstractConvertLinqQueryToForEachProvider.cs b/src/Features/Core/Portable/ConvertLinq/AbstractConvertLinqQueryToForEachProvider.cs index 65e19fa3c2312..b727c492dd8d0 100644 --- a/src/Features/Core/Portable/ConvertLinq/AbstractConvertLinqQueryToForEachProvider.cs +++ b/src/Features/Core/Portable/ConvertLinq/AbstractConvertLinqQueryToForEachProvider.cs @@ -45,9 +45,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte if (TryConvert(queryExpression, semanticModel, semanticFacts, cancellationToken, out var documentUpdateInfo)) { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( Title, - c => Task.FromResult(document.WithSyntaxRoot(documentUpdateInfo.UpdateRoot(root)))), + c => Task.FromResult(document.WithSyntaxRoot(documentUpdateInfo.UpdateRoot(root))), + nameof(Title)), queryExpression.Span); } } @@ -88,13 +89,5 @@ public SyntaxNode UpdateRoot(SyntaxNode root) } } } - - protected sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs index e23aaa5ef077e..7b0e927686e1c 100644 --- a/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertNumericLiteral/AbstractConvertNumericLiteralCodeRefactoringProvider.cs @@ -105,7 +105,7 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex void RegisterRefactoringWithResult(string text, string title) { context.RegisterRefactoring( - new MyCodeAction(title, c => ReplaceTokenAsync(document, root, numericToken, value, text, suffix)), + CodeAction.Create(title, c => ReplaceTokenAsync(document, root, numericToken, value, text, suffix), title), numericToken.Span); } } @@ -168,12 +168,5 @@ private static bool IsIntegral(SpecialType specialType) } private enum NumericKind { Unknown, Decimal, Binary, Hexadecimal } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs b/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs index f716c84f7ddee..03165d2a219d1 100644 --- a/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertToInterpolatedString/AbstractConvertConcatenationToInterpolatedStringRefactoringProvider.cs @@ -106,8 +106,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false); var interpolatedString = CreateInterpolatedString(document, isVerbatimStringLiteral, pieces); context.RegisterRefactoring( - new MyCodeAction( - _ => UpdateDocumentAsync(document, root, top, interpolatedString)), + CodeAction.Create( + FeaturesResources.Convert_to_interpolated_string, + _ => UpdateDocumentAsync(document, root, top, interpolatedString), + nameof(FeaturesResources.Convert_to_interpolated_string)), top.Span); } @@ -250,13 +252,5 @@ private static bool IsStringConcat( (method.MetadataName == WellKnownMemberNames.AdditionOperatorName || method.MetadataName == WellKnownMemberNames.ConcatenateOperatorName); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Convert_to_interpolated_string, createChangedDocument, nameof(FeaturesResources.Convert_to_interpolated_string)) - { - } - } } } diff --git a/src/Features/Core/Portable/ConvertToInterpolatedString/ConvertRegularStringToInterpolatedStringRefactoringProvider.cs b/src/Features/Core/Portable/ConvertToInterpolatedString/ConvertRegularStringToInterpolatedStringRefactoringProvider.cs index d90e74f4cd538..bec5199cb40c6 100644 --- a/src/Features/Core/Portable/ConvertToInterpolatedString/ConvertRegularStringToInterpolatedStringRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertToInterpolatedString/ConvertRegularStringToInterpolatedStringRefactoringProvider.cs @@ -73,7 +73,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte } context.RegisterRefactoring( - new MyCodeAction(_ => UpdateDocumentAsync(document, root, token)), + new PriorityBasedCodeAction(_ => UpdateDocumentAsync(document, root, token)), literalExpression.Span); } @@ -110,11 +110,11 @@ private static Task UpdateDocumentAsync(Document document, SyntaxNode CreateInterpolatedString(document, literalExpression, syntaxFacts.IsVerbatimStringLiteral(token))))); } - private class MyCodeAction : CodeAction.DocumentChangeAction + private class PriorityBasedCodeAction : CodeAction.DocumentChangeAction { internal override CodeActionPriority Priority => CodeActionPriority.Low; - public MyCodeAction(Func> createChangedDocument) + public PriorityBasedCodeAction(Func> createChangedDocument) : base(FeaturesResources.Convert_to_interpolated_string, createChangedDocument, nameof(FeaturesResources.Convert_to_interpolated_string)) { } diff --git a/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs b/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs index 0c52371a02d84..b86a3b96946a0 100644 --- a/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ConvertTupleToStruct/AbstractConvertTupleToStructCodeRefactoringProvider.cs @@ -170,7 +170,7 @@ ImmutableArray CreateChildActions( } private CodeAction CreateAction(Document document, TextSpan span, Scope scope, CodeCleanupOptionsProvider fallbackOptions, bool isRecord) - => new MyCodeAction(GetTitle(scope), c => ConvertToStructAsync(document, span, scope, fallbackOptions, isRecord, c), scope.ToString()); + => CodeAction.Create(GetTitle(scope), c => ConvertToStructAsync(document, span, scope, fallbackOptions, isRecord, c), scope.ToString()); private static string GetTitle(Scope scope) => scope switch @@ -939,16 +939,5 @@ private static IMethodSymbol CreateConstructor( return constructor; } - - private class MyCodeAction : CodeAction.SolutionChangeAction - { - public MyCodeAction( - string title, - Func> createChangedSolution, - string equivalenceKey) - : base(title, createChangedSolution, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractAddDocCommentNodesCodeFixProvider.cs b/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractAddDocCommentNodesCodeFixProvider.cs index 856b2964af1ae..14dbe2b659d2c 100644 --- a/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractAddDocCommentNodesCodeFixProvider.cs +++ b/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractAddDocCommentNodesCodeFixProvider.cs @@ -34,8 +34,10 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) if (parentMethod != null && TryGetDocCommentNode(parentMethod.GetLeadingTrivia()) != null) { context.RegisterCodeFix( - new MyCodeAction( - c => AddParamTagAsync(context.Document, context.Span, c)), + CodeAction.Create( + FeaturesResources.Add_missing_param_nodes, + c => AddParamTagAsync(context.Document, context.Span, c), + nameof(FeaturesResources.Add_missing_param_nodes)), context.Diagnostics); } } @@ -174,13 +176,5 @@ protected TXmlElementSyntax GetParamNodeForParamName( return null; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Add_missing_param_nodes, createChangedDocument, nameof(FeaturesResources.Add_missing_param_nodes)) - { - } - } } } diff --git a/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractRemoveDocCommentNodeCodeFixProvider.cs b/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractRemoveDocCommentNodeCodeFixProvider.cs index a399ddc35d411..987606df58241 100644 --- a/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractRemoveDocCommentNodeCodeFixProvider.cs +++ b/src/Features/Core/Portable/DocumentationComments/CodeFixes/AbstractRemoveDocCommentNodeCodeFixProvider.cs @@ -39,8 +39,10 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) if (GetParamNode(root, context.Span) != null) { context.RegisterCodeFix( - new MyCodeAction( - c => RemoveDuplicateParamTagAsync(context.Document, context.Span, c)), + CodeAction.Create( + FeaturesResources.Remove_tag, + c => RemoveDuplicateParamTagAsync(context.Document, context.Span, c), + nameof(FeaturesResources.Remove_tag)), context.Diagnostics); } } @@ -122,13 +124,5 @@ private bool ShouldRemovePreviousSibling(List paramNodeSiblings, int return false; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Remove_tag, createChangedDocument, nameof(FeaturesResources.Remove_tag)) - { - } - } } } diff --git a/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionCodeFixProvider.cs b/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionCodeFixProvider.cs index e7c51e05883b1..68d0decb53588 100644 --- a/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionCodeFixProvider.cs +++ b/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionCodeFixProvider.cs @@ -35,7 +35,12 @@ public override ImmutableArray FixableDiagnosticIds public override Task RegisterCodeFixesAsync(CodeFixContext context) { - context.RegisterCodeFix(new MyCodeAction(GetDocumentUpdater(context)), context.Diagnostics); + context.RegisterCodeFix( + CodeAction.Create( + FeaturesResources.Enable_all_JSON_editor_features, + GetDocumentUpdater(context), + nameof(FeaturesResources.Enable_all_JSON_editor_features)), + context.Diagnostics); return Task.CompletedTask; } @@ -60,13 +65,5 @@ protected override Task FixAllAsync( return Task.CompletedTask; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Enable_all_JSON_editor_features, createChangedDocument, nameof(FeaturesResources.Enable_all_JSON_editor_features)) - { - } - } } } diff --git a/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs b/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs index 0821d0e696768..5c8a174718b12 100644 --- a/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs +++ b/src/Features/Core/Portable/EncapsulateField/AbstractEncapsulateFieldService.cs @@ -74,25 +74,29 @@ public async Task> GetEncapsulateFieldCodeActionsAsyn private ImmutableArray EncapsulateAllFields(Document document, ImmutableArray fields, CodeCleanupOptionsProvider fallbackOptions) { - return ImmutableArray.Create( - new MyCodeAction( + return ImmutableArray.Create( + CodeAction.Create( FeaturesResources.Encapsulate_fields_and_use_property, - c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: true, c)), - new MyCodeAction( + c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: true, c), + nameof(FeaturesResources.Encapsulate_fields_and_use_property)), + CodeAction.Create( FeaturesResources.Encapsulate_fields_but_still_use_field, - c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: false, c))); + c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: false, c), + nameof(FeaturesResources.Encapsulate_fields_but_still_use_field))); } private ImmutableArray EncapsulateOneField(Document document, IFieldSymbol field, CodeCleanupOptionsProvider fallbackOptions) { var fields = ImmutableArray.Create(field); - return ImmutableArray.Create( - new MyCodeAction( + return ImmutableArray.Create( + CodeAction.Create( string.Format(FeaturesResources.Encapsulate_field_colon_0_and_use_property, field.Name), - c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: true, c)), - new MyCodeAction( + c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: true, c), + nameof(FeaturesResources.Encapsulate_field_colon_0_and_use_property)), + CodeAction.Create( string.Format(FeaturesResources.Encapsulate_field_colon_0_but_still_use_field, field.Name), - c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: false, c))); + c => EncapsulateFieldsAsync(document, fields, fallbackOptions, updateReferences: false, c), + nameof(FeaturesResources.Encapsulate_field_colon_0_but_still_use_field))); } public async Task EncapsulateFieldsAsync( @@ -459,13 +463,5 @@ protected static string GeneratePropertyName(string fieldName) } private static readonly CultureInfo EnUSCultureInfo = new("en-US"); - - private class MyCodeAction : CodeAction.SolutionChangeAction - { - public MyCodeAction(string title, Func> createChangedSolution) - : base(title, createChangedSolution, title) - { - } - } } } diff --git a/src/Features/Core/Portable/FullyQualify/AbstractFullyQualifyCodeFixProvider.cs b/src/Features/Core/Portable/FullyQualify/AbstractFullyQualifyCodeFixProvider.cs index 0d9a624da1027..4fed501b7239e 100644 --- a/src/Features/Core/Portable/FullyQualify/AbstractFullyQualifyCodeFixProvider.cs +++ b/src/Features/Core/Portable/FullyQualify/AbstractFullyQualifyCodeFixProvider.cs @@ -122,9 +122,10 @@ private IEnumerable CreateActions( memberName = name; } - var codeAction = new MyCodeAction( + var codeAction = CodeAction.Create( $"{containerName}.{memberName}", - c => ProcessNodeAsync(document, node, containerName, symbolResult.OriginalSymbol, c)); + c => ProcessNodeAsync(document, node, containerName, symbolResult.OriginalSymbol, c), + nameof(AbstractFullyQualifyCodeFixProvider)); yield return codeAction; } @@ -335,14 +336,6 @@ private static IEnumerable FilterAndSort(IEnumerable .Where(n => n.Symbol is INamedTypeSymbol || !((INamespaceSymbol)n.Symbol).IsGlobalNamespace) .Order(); - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, equivalenceKey: title) - { - } - } - private class GroupingCodeAction : CodeAction.CodeActionWithNestedActions { public GroupingCodeAction(string title, ImmutableArray nestedActions) diff --git a/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs b/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs index 90ccc457d8363..4754890dc16fd 100644 --- a/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/GenerateComparisonOperators/GenerateComparisonOperatorsCodeRefactoringProvider.cs @@ -94,7 +94,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte if (missingComparableTypes.Count == 1) { var missingType = missingComparableTypes[0]; - context.RegisterRefactoring(new MyCodeAction( + context.RegisterRefactoring(CodeAction.Create( FeaturesResources.Generate_comparison_operators, c => GenerateComparisonOperatorsAsync(document, typeDeclaration, missingType, c), nameof(FeaturesResources.Generate_comparison_operators))); @@ -107,7 +107,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte { var typeArg = missingType.TypeArguments[0]; var displayString = typeArg.ToMinimalDisplayString(semanticModel, textSpan.Start); - nestedActions.Add(new MyCodeAction( + nestedActions.Add(CodeAction.Create( string.Format(FeaturesResources.Generate_for_0, displayString), c => GenerateComparisonOperatorsAsync(document, typeDeclaration, missingType, c), nameof(FeaturesResources.Generate_for_0) + "_" + displayString)); @@ -260,13 +260,5 @@ private static string GetOperatorName(CodeGenerationOperatorKind kind) CodeGenerationOperatorKind.GreaterThanOrEqual => WellKnownMemberNames.GreaterThanOrEqualOperatorName, _ => throw ExceptionUtilities.Unreachable, }; - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument, string equivalenceKey) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs index 1d58ae04b7ca0..7170af99d2699 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs +++ b/src/Features/Core/Portable/GenerateMember/GenerateConstructor/AbstractGenerateConstructorService.cs @@ -91,23 +91,26 @@ public async Task> GenerateConstructorAsync(Document // If we have any fields we'd like to generate, offer a code action to do that. if (state.ParameterToNewFieldMap.Count > 0) { - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( string.Format(FeaturesResources.Generate_constructor_in_0_with_fields, state.TypeToGenerateIn.Name), - c => state.GetChangedDocumentAsync(document, withFields: true, withProperties: false, c))); + c => state.GetChangedDocumentAsync(document, withFields: true, withProperties: false, c), + nameof(FeaturesResources.Generate_constructor_in_0_with_fields))); } // Same with a version that generates properties instead. if (state.ParameterToNewPropertyMap.Count > 0) { - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( string.Format(FeaturesResources.Generate_constructor_in_0_with_properties, state.TypeToGenerateIn.Name), - c => state.GetChangedDocumentAsync(document, withFields: false, withProperties: true, c))); + c => state.GetChangedDocumentAsync(document, withFields: false, withProperties: true, c), + nameof(FeaturesResources.Generate_constructor_in_0_with_properties))); } // Always offer to just generate the constructor and nothing else. - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( string.Format(FeaturesResources.Generate_constructor_in_0, state.TypeToGenerateIn.Name), - c => state.GetChangedDocumentAsync(document, withFields: false, withProperties: false, c))); + c => state.GetChangedDocumentAsync(document, withFields: false, withProperties: false, c), + nameof(FeaturesResources.Generate_constructor_in_0))); return result.ToImmutable(); } @@ -182,13 +185,5 @@ private ImmutableArray GenerateParameterNames( .Select((name, index) => new ParameterName(name, isFixed[index], parameterNamingRule)) .Skip(reservedNames.Count).ToImmutableArray(); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs index 25eea99b90011..735c715bceaa3 100644 --- a/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs +++ b/src/Features/Core/Portable/GenerateMember/GenerateVariable/AbstractGenerateVariableService.cs @@ -79,9 +79,10 @@ public async Task> GenerateVariableAsync( { // Wrap the generate variable actions into a single top level suggestion // so as to not clutter the list. - return ImmutableArray.Create(new MyCodeAction( + return ImmutableArray.Create(CodeAction.Create( string.Format(FeaturesResources.Generate_variable_0, state.IdentifierToken.ValueText), - actions.ToImmutable())); + actions.ToImmutable(), + isInlinable: true)); } return actions.ToImmutable(); @@ -230,13 +231,5 @@ private static RefKind GetRefKindFromContext(State state) return RefKind.None; } } - - private class MyCodeAction : CodeAction.CodeActionWithNestedActions - { - public MyCodeAction(string title, ImmutableArray nestedActions) - : base(title, nestedActions, isInlinable: true) - { - } - } } } diff --git a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.cs b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.cs index 896e92300c1de..c6232b2780723 100644 --- a/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.cs +++ b/src/Features/Core/Portable/GenerateType/AbstractGenerateTypeService.cs @@ -83,8 +83,10 @@ public async Task> GenerateTypeAsync( { // Wrap the generate type actions into a single top level suggestion // so as to not clutter the list. - return ImmutableArray.Create(new MyCodeAction( - string.Format(FeaturesResources.Generate_type_0, state.Name), actions.AsImmutable())); + return ImmutableArray.Create(CodeAction.Create( + string.Format(FeaturesResources.Generate_type_0, state.Name), + actions.AsImmutable(), + isInlinable: true)); } else { @@ -296,13 +298,5 @@ protected static bool GeneratedTypesMustBePublic(Project project) return false; } - - private class MyCodeAction : CodeAction.CodeActionWithNestedActions - { - public MyCodeAction(string title, ImmutableArray nestedActions) - : base(title, nestedActions, isInlinable: true) - { - } - } } } diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs b/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs index 01ef17c1bd039..ecb8704907119 100644 --- a/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs @@ -69,7 +69,7 @@ protected override async Task> GetRefactoringsForAllP return ImmutableArray.Empty; // Great. The list has parameters that need null checks. Offer to add null checks for all. - return ImmutableArray.Create(new MyCodeAction( + return ImmutableArray.Create(CodeAction.Create( FeaturesResources.Add_null_checks_for_all_parameters, c => UpdateDocumentForRefactoringAsync(document, blockStatementOpt, listOfParametersOrdinals, parameterSpan, c), nameof(FeaturesResources.Add_null_checks_for_all_parameters))); @@ -92,7 +92,7 @@ protected override async Task> GetRefactoringsForSing // Great. There was no null check. Offer to add one. using var result = TemporaryArray.Empty; - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( FeaturesResources.Add_null_check, c => AddNullCheckAsync(document, parameterSyntax, parameter, funcOrRecord, methodSymbol, blockStatementOpt, c), nameof(FeaturesResources.Add_null_check))); @@ -102,12 +102,12 @@ protected override async Task> GetRefactoringsForSing // to place the checks. if (parameter.Type.SpecialType == SpecialType.System_String && !IsRecordDeclaration(funcOrRecord)) { - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( FeaturesResources.Add_string_IsNullOrEmpty_check, c => AddStringCheckAsync(document, parameter, funcOrRecord, methodSymbol, blockStatementOpt, nameof(string.IsNullOrEmpty), c), nameof(FeaturesResources.Add_string_IsNullOrEmpty_check))); - result.Add(new MyCodeAction( + result.Add(CodeAction.Create( FeaturesResources.Add_string_IsNullOrWhiteSpace_check, c => AddStringCheckAsync(document, parameter, funcOrRecord, methodSymbol, blockStatementOpt, nameof(string.IsNullOrWhiteSpace), c), nameof(FeaturesResources.Add_string_IsNullOrWhiteSpace_check))); diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs index 877209aba34b9..0de293cd32ff8 100644 --- a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs +++ b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeMemberFromParameterCodeRefactoringProviderMemberCreation.cs @@ -171,14 +171,16 @@ private async Task> HandleNoExistingFieldOrPropertyAs var fields = parameters.SelectAsArray(p => (ISymbol)CreateField(p, options, rules)); var properties = parameters.SelectAsArray(p => (ISymbol)CreateProperty(p, options, rules)); - var allFieldsAction = new MyCodeAction( + var allFieldsAction = CodeAction.Create( FeaturesResources.Create_and_assign_remaining_as_fields, c => AddAllSymbolInitializationsAsync( - document, constructorDeclaration, blockStatementOpt, parameters, fields, c)); - var allPropertiesAction = new MyCodeAction( + document, constructorDeclaration, blockStatementOpt, parameters, fields, c), + nameof(FeaturesResources.Create_and_assign_remaining_as_fields)); + var allPropertiesAction = CodeAction.Create( FeaturesResources.Create_and_assign_remaining_as_properties, c => AddAllSymbolInitializationsAsync( - document, constructorDeclaration, blockStatementOpt, parameters, properties, c)); + document, constructorDeclaration, blockStatementOpt, parameters, properties, c), + nameof(FeaturesResources.Create_and_assign_remaining_as_properties)); return (allFieldsAction, allPropertiesAction); } @@ -193,12 +195,14 @@ private async Task> HandleNoExistingFieldOrPropertyAs { var field = CreateField(parameter, options, rules); var property = CreateProperty(parameter, options, rules); - var fieldAction = new MyCodeAction( + var fieldAction = CodeAction.Create( string.Format(FeaturesResources.Create_and_assign_field_0, field.Name), - c => AddSingleSymbolInitializationAsync(document, constructorDeclaration, blockStatementOpt, parameter, field, c)); - var propertyAction = new MyCodeAction( + c => AddSingleSymbolInitializationAsync(document, constructorDeclaration, blockStatementOpt, parameter, field, c), + nameof(FeaturesResources.Create_and_assign_field_0)); + var propertyAction = CodeAction.Create( string.Format(FeaturesResources.Create_and_assign_property_0, property.Name), - c => AddSingleSymbolInitializationAsync(document, constructorDeclaration, blockStatementOpt, parameter, property, c)); + c => AddSingleSymbolInitializationAsync(document, constructorDeclaration, blockStatementOpt, parameter, property, c), + nameof(FeaturesResources.Create_and_assign_property_0)); return (fieldAction, propertyAction); } @@ -237,10 +241,11 @@ private ImmutableArray HandleExistingFieldOrProperty(Document docume var title = string.Format(resource, fieldOrProperty.Name); - return ImmutableArray.Create(new MyCodeAction( + return ImmutableArray.Create(CodeAction.Create( title, c => AddSingleSymbolInitializationAsync( - document, functionDeclaration, blockStatementOpt, parameter, fieldOrProperty, c))); + document, functionDeclaration, blockStatementOpt, parameter, fieldOrProperty, c), + title)); } private static ISymbol? TryFindSiblingFieldOrProperty(IParameterSymbol parameter, IBlockOperation? blockStatementOpt) diff --git a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs index afb66666f0c42..d46a6d1d226e0 100644 --- a/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/InitializeParameter/AbstractInitializeParameterCodeRefactoringProvider.cs @@ -272,13 +272,5 @@ protected static bool IsFieldOrPropertyReference( fieldOrProperty = null; return false; } - - protected class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument, string? equivalenceKey = null) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/IntroduceUsingStatement/AbstractIntroduceUsingStatementCodeRefactoringProvider.cs b/src/Features/Core/Portable/IntroduceUsingStatement/AbstractIntroduceUsingStatementCodeRefactoringProvider.cs index b775d534cdbbb..e757d4943db53 100644 --- a/src/Features/Core/Portable/IntroduceUsingStatement/AbstractIntroduceUsingStatementCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/IntroduceUsingStatement/AbstractIntroduceUsingStatementCodeRefactoringProvider.cs @@ -8,6 +8,7 @@ using System.Linq; using System.Threading; using System.Threading.Tasks; +using Microsoft.CodeAnalysis.CodeActions; using Microsoft.CodeAnalysis.CodeRefactorings; using Microsoft.CodeAnalysis.Formatting; using Microsoft.CodeAnalysis.LanguageServices; @@ -41,9 +42,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte if (declarationSyntax != null) { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( CodeActionTitle, - cancellationToken => IntroduceUsingStatementAsync(document, declarationSyntax, cancellationToken)), + cancellationToken => IntroduceUsingStatementAsync(document, declarationSyntax, cancellationToken), + nameof(CodeActionTitle)), declarationSyntax.Span); } } @@ -311,13 +313,5 @@ private static void AddReferencedLocalVariables( AddReferencedLocalVariables(referencedVariables, childNode, localVariables, semanticModel, syntaxFactsService, cancellationToken); } } - - private sealed class MyCodeAction : DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs b/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs index d90a39faee03d..c4a075832f2ae 100644 --- a/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs +++ b/src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceParameterService.cs @@ -185,10 +185,12 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex return (actionsBuilder.ToImmutableAndClear(), actionsBuilderAllOccurrences.ToImmutableAndClear()); // Local function to create a code action with more ease - MyCodeAction CreateNewCodeAction(string actionName, bool allOccurrences, IntroduceParameterCodeActionKind selectedCodeAction) + CodeAction CreateNewCodeAction(string actionName, bool allOccurrences, IntroduceParameterCodeActionKind selectedCodeAction) { - return new MyCodeAction(actionName, c => IntroduceParameterAsync( - document, expression, methodSymbol, containingMethod, allOccurrences, selectedCodeAction, c)); + return CodeAction.Create( + actionName, + c => IntroduceParameterAsync(document, expression, methodSymbol, containingMethod, allOccurrences, selectedCodeAction, c), + actionName); } } @@ -318,14 +320,6 @@ await SymbolFinder.FindReferencesAsync( return methodCallSites; } - private class MyCodeAction : SolutionChangeAction - { - public MyCodeAction(string title, Func> createChangedSolution) - : base(title, createChangedSolution, title) - { - } - } - private enum IntroduceParameterCodeActionKind { Refactor, diff --git a/src/Features/Core/Portable/IntroduceVariable/IntroduceLocalForExpressionCodeRefactoringProvider.cs b/src/Features/Core/Portable/IntroduceVariable/IntroduceLocalForExpressionCodeRefactoringProvider.cs index b7724a4a7adf8..44280c9d4ffb4 100644 --- a/src/Features/Core/Portable/IntroduceVariable/IntroduceLocalForExpressionCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/IntroduceVariable/IntroduceLocalForExpressionCodeRefactoringProvider.cs @@ -53,9 +53,10 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex var nodeString = singleLineExpression.ToString(); context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( string.Format(FeaturesResources.Introduce_local_for_0, nodeString), - c => IntroduceLocalAsync(document, expressionStatement, c)), + c => IntroduceLocalAsync(document, expressionStatement, c), + nameof(FeaturesResources.Introduce_local_for_0) + nodeString), expressionStatement.Span); } @@ -107,13 +108,5 @@ protected static async Task GenerateUniqueNameAsync( .WithAdditionalAnnotations(RenameAnnotation.Create()); return uniqueName; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs b/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs index 8ee19478f33f3..f076a466a50dc 100644 --- a/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/InvertConditional/AbstractInvertConditionalCodeRefactoringProvider.cs @@ -33,8 +33,11 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte return; } - context.RegisterRefactoring(new MyCodeAction( - c => InvertConditionalAsync(document, conditional, c)), + context.RegisterRefactoring( + CodeAction.Create( + FeaturesResources.Invert_conditional, + c => InvertConditionalAsync(document, conditional, c), + nameof(FeaturesResources.Invert_conditional)), conditional.Span); } @@ -87,13 +90,5 @@ private static async Task InvertConditionalAsync( return document.WithSyntaxRoot(editor.GetChangedRoot()); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Invert_conditional, createChangedDocument, nameof(FeaturesResources.Invert_conditional)) - { - } - } } } diff --git a/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs b/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs index 4b8f208629a32..c0611e7a4158d 100644 --- a/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/InvertIf/AbstractInvertIfCodeRefactoringProvider.cs @@ -53,8 +53,10 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex } context.RegisterRefactoring( - new MyCodeAction(GetTitle(), - c => InvertIfAsync(document, ifNode, c)), + CodeAction.Create( + GetTitle(), + c => InvertIfAsync(document, ifNode, c), + nameof(GetTitle)), ifNode.Span); } @@ -590,13 +592,5 @@ private SyntaxNode GetRootWithInvertIfStatement( throw ExceptionUtilities.UnexpectedValue(invertIfStyle); } } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/InvertLogical/AbstractInvertLogicalCodeRefactoringProvider.cs b/src/Features/Core/Portable/InvertLogical/AbstractInvertLogicalCodeRefactoringProvider.cs index 895a7c5c1b6db..7322ab1086bcc 100644 --- a/src/Features/Core/Portable/InvertLogical/AbstractInvertLogicalCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/InvertLogical/AbstractInvertLogicalCodeRefactoringProvider.cs @@ -72,9 +72,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte } context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( GetTitle(syntaxKinds, expression.RawKind), - c => InvertLogicalAsync(document, expression, c)), + c => InvertLogicalAsync(document, expression, c), + nameof(GetTitle)), expression.Span); } @@ -144,13 +145,5 @@ private static int InvertedKind(ISyntaxKindsService syntaxKinds, int binaryExprK => binaryExprKind == syntaxKinds.LogicalAndExpression ? syntaxKinds.LogicalOrExpression : syntaxKinds.LogicalAndExpression; - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/MakeMethodAsynchronous/AbstractMakeMethodAsynchronousCodeFixProvider.cs b/src/Features/Core/Portable/MakeMethodAsynchronous/AbstractMakeMethodAsynchronousCodeFixProvider.cs index 4e70c8f267af3..fab598f6389fe 100644 --- a/src/Features/Core/Portable/MakeMethodAsynchronous/AbstractMakeMethodAsynchronousCodeFixProvider.cs +++ b/src/Features/Core/Portable/MakeMethodAsynchronous/AbstractMakeMethodAsynchronousCodeFixProvider.cs @@ -61,8 +61,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) // Offer to convert to a Task return type. context.RegisterCodeFix( - new MyCodeAction(GetMakeAsyncTaskFunctionResource(), c => FixNodeAsync( - context.Document, diagnostic, keepVoid: false, isEntryPoint, cancellationToken: c)), + CodeAction.Create( + GetMakeAsyncTaskFunctionResource(), + c => FixNodeAsync(context.Document, diagnostic, keepVoid: false, isEntryPoint, cancellationToken: c), + nameof(GetMakeAsyncTaskFunctionResource)), context.Diagnostics); // If it's a void returning method (and not an entry point), also offer to keep the void return type @@ -70,8 +72,10 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) if (isOrdinaryOrLocalFunction && symbol.ReturnsVoid && !isEntryPoint) { context.RegisterCodeFix( - new MyCodeAction(GetMakeAsyncVoidFunctionResource(), c => FixNodeAsync( - context.Document, diagnostic, keepVoid: true, isEntryPoint: false, cancellationToken: c)), + CodeAction.Create( + GetMakeAsyncVoidFunctionResource(), + c => FixNodeAsync(context.Document, diagnostic, keepVoid: true, isEntryPoint: false, cancellationToken: c), + nameof(GetMakeAsyncVoidFunctionResource)), context.Diagnostics); } } @@ -229,13 +233,5 @@ protected static bool IsTaskLike(ITypeSymbol returnType, KnownTypes knownTypes) return false; } - - private class MyCodeAction : CodeAction.SolutionChangeAction - { - public MyCodeAction(string title, Func> createChangedSolution) - : base(title, createChangedSolution, equivalenceKey: title) - { - } - } } } diff --git a/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs b/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs index 2719460e484ad..674f90dbdd260 100644 --- a/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs +++ b/src/Features/Core/Portable/MakeMethodSynchronous/AbstractMakeMethodSynchronousCodeFixProvider.cs @@ -25,8 +25,6 @@ namespace Microsoft.CodeAnalysis.MakeMethodSynchronous { internal abstract class AbstractMakeMethodSynchronousCodeFixProvider : CodeFixProvider { - public static readonly string EquivalenceKey = FeaturesResources.Make_method_synchronous; - protected abstract bool IsAsyncSupportingFunctionSyntax(SyntaxNode node); protected abstract SyntaxNode RemoveAsyncTokenAndFixReturnType(IMethodSymbol methodSymbolOpt, SyntaxNode node, KnownTypes knownTypes); @@ -35,7 +33,10 @@ internal abstract class AbstractMakeMethodSynchronousCodeFixProvider : CodeFixPr public override Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( - new MyCodeAction(c => FixNodeAsync(context.Document, context.Diagnostics.First(), c)), + CodeAction.Create( + FeaturesResources.Make_method_synchronous, + c => FixNodeAsync(context.Document, context.Diagnostics.First(), c), + nameof(FeaturesResources.Make_method_synchronous)), context.Diagnostics); return Task.CompletedTask; } @@ -250,13 +251,5 @@ private static void RemoveAwaitFromCallerIfPresent( } } } - - private class MyCodeAction : CodeAction.SolutionChangeAction - { - public MyCodeAction(Func> createChangedSolution) - : base(FeaturesResources.Make_method_synchronous, createChangedSolution, AbstractMakeMethodSynchronousCodeFixProvider.EquivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs b/src/Features/Core/Portable/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs index 58f64598b9903..ea2dd76bc8dcf 100644 --- a/src/Features/Core/Portable/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/MoveDeclarationNearReference/AbstractMoveDeclarationNearReferenceCodeRefactoringProvider.cs @@ -43,7 +43,7 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte } context.RegisterRefactoring( - new MyCodeAction(c => MoveDeclarationNearReferenceAsync(document, declaration, c)), + new LowPriorityCodeAction(c => MoveDeclarationNearReferenceAsync(document, declaration, c)), declaration.Span); } @@ -54,9 +54,9 @@ private static async Task MoveDeclarationNearReferenceAsync( return await service.MoveDeclarationNearReferenceAsync(document, statement, cancellationToken).ConfigureAwait(false); } - private class MyCodeAction : CodeAction.DocumentChangeAction + private class LowPriorityCodeAction : CodeAction.DocumentChangeAction { - public MyCodeAction(Func> createChangedDocument) + public LowPriorityCodeAction(Func> createChangedDocument) : base(FeaturesResources.Move_declaration_near_reference, createChangedDocument, nameof(FeaturesResources.Move_declaration_near_reference)) { } diff --git a/src/Features/Core/Portable/NameTupleElement/AbstractNameTupleElementCodeRefactoringProvider.cs b/src/Features/Core/Portable/NameTupleElement/AbstractNameTupleElementCodeRefactoringProvider.cs index 1392b09d085fc..aba216c4012e8 100644 --- a/src/Features/Core/Portable/NameTupleElement/AbstractNameTupleElementCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/NameTupleElement/AbstractNameTupleElementCodeRefactoringProvider.cs @@ -31,9 +31,10 @@ public override async Task ComputeRefactoringsAsync(CodeRefactoringContext conte } context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( string.Format(FeaturesResources.Add_tuple_element_name_0, elementName), - c => AddNamedElementAsync(document, span, cancellationToken)), + c => AddNamedElementAsync(document, span, cancellationToken), + nameof(FeaturesResources.Add_tuple_element_name_0) + elementName), argument.Span); } @@ -87,13 +88,5 @@ private async Task AddNamedElementAsync(Document document, TextSpan sp var newRoot = root.ReplaceNode(argument, newArgument); return document.WithSyntaxRoot(newRoot); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/RemoveAsyncModifier/AbstractRemoveAsyncModifierCodeFixProvider.cs b/src/Features/Core/Portable/RemoveAsyncModifier/AbstractRemoveAsyncModifierCodeFixProvider.cs index 7fe36ff307677..529c5846e65c0 100644 --- a/src/Features/Core/Portable/RemoveAsyncModifier/AbstractRemoveAsyncModifierCodeFixProvider.cs +++ b/src/Features/Core/Portable/RemoveAsyncModifier/AbstractRemoveAsyncModifierCodeFixProvider.cs @@ -51,7 +51,12 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context) if (ShouldOfferFix(methodSymbol.ReturnType, knownTypes)) { - context.RegisterCodeFix(new MyCodeAction(GetDocumentUpdater(context)), context.Diagnostics); + context.RegisterCodeFix( + CodeAction.Create( + FeaturesResources.Remove_async_modifier, + GetDocumentUpdater(context), + nameof(FeaturesResources.Remove_async_modifier)), + context.Diagnostics); } } @@ -246,13 +251,5 @@ static SyntaxNode QualifiedNameToMemberAccess(int qualifiedNameSyntaxKind, int m return expression; } } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Remove_async_modifier, createChangedDocument, FeaturesResources.Remove_async_modifier) - { - } - } } } diff --git a/src/Features/Core/Portable/RemoveUnusedVariable/AbstractRemoveUnusedVariableCodeFixProvider.cs b/src/Features/Core/Portable/RemoveUnusedVariable/AbstractRemoveUnusedVariableCodeFixProvider.cs index a7edd569713e0..a2435223bf191 100644 --- a/src/Features/Core/Portable/RemoveUnusedVariable/AbstractRemoveUnusedVariableCodeFixProvider.cs +++ b/src/Features/Core/Portable/RemoveUnusedVariable/AbstractRemoveUnusedVariableCodeFixProvider.cs @@ -47,7 +47,14 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) var blockFacts = document.GetRequiredLanguageService(); if (ShouldOfferFixForLocalDeclaration(blockFacts, node)) - context.RegisterCodeFix(new MyCodeAction(GetDocumentUpdater(context)), diagnostic); + { + context.RegisterCodeFix( + CodeAction.Create( + FeaturesResources.Remove_unused_variable, + GetDocumentUpdater(context), + nameof(FeaturesResources.Remove_unused_variable)), + diagnostic); + } } protected override async Task FixAllAsync(Document document, ImmutableArray diagnostics, SyntaxEditor syntaxEditor, CodeActionOptionsProvider fallbackOptions, CancellationToken cancellationToken) @@ -194,13 +201,5 @@ private void MergeNodesToRemove(HashSet nodesToRemove) } } } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(FeaturesResources.Remove_unused_variable, createChangedDocument, FeaturesResources.Remove_unused_variable) - { - } - } } } diff --git a/src/Features/Core/Portable/ReplaceDocCommentTextWithTag/AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs b/src/Features/Core/Portable/ReplaceDocCommentTextWithTag/AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs index 76b8728c79add..abeb4ae66686e 100644 --- a/src/Features/Core/Portable/ReplaceDocCommentTextWithTag/AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/ReplaceDocCommentTextWithTag/AbstractReplaceDocCommentTextWithTagCodeRefactoringProvider.cs @@ -156,9 +156,10 @@ private static void RegisterRefactoring( CodeRefactoringContext context, TextSpan expandedSpan, string replacement) { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( string.Format(FeaturesResources.Use_0, replacement), - c => ReplaceTextAsync(context.Document, expandedSpan, replacement, c)), + c => ReplaceTextAsync(context.Document, expandedSpan, replacement, c), + nameof(FeaturesResources.Use_0) + replacement), expandedSpan); } @@ -234,13 +235,5 @@ private static bool ShouldExpandSpanBackwardOneCharacter( return false; } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/SimplifyThisOrMe/AbstractSimplifyThisOrMeCodeFixProvider.cs b/src/Features/Core/Portable/SimplifyThisOrMe/AbstractSimplifyThisOrMeCodeFixProvider.cs index c4b05749652b4..f9d482283912a 100644 --- a/src/Features/Core/Portable/SimplifyThisOrMe/AbstractSimplifyThisOrMeCodeFixProvider.cs +++ b/src/Features/Core/Portable/SimplifyThisOrMe/AbstractSimplifyThisOrMeCodeFixProvider.cs @@ -30,10 +30,12 @@ internal abstract partial class AbstractSimplifyThisOrMeCodeFixProvider> createChangedDocument, string equivalenceKey) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/SimplifyTypeNames/AbstractSimplifyTypeNamesCodeFixProvider.cs b/src/Features/Core/Portable/SimplifyTypeNames/AbstractSimplifyTypeNamesCodeFixProvider.cs index 3cf4e92da0378..4b11dab8d3a37 100644 --- a/src/Features/Core/Portable/SimplifyTypeNames/AbstractSimplifyTypeNamesCodeFixProvider.cs +++ b/src/Features/Core/Portable/SimplifyTypeNames/AbstractSimplifyTypeNamesCodeFixProvider.cs @@ -90,10 +90,12 @@ public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) var syntaxFacts = document.GetLanguageService(); var title = GetTitle(diagnosticId, syntaxFacts.ConvertToSingleLine(node).ToString()); - context.RegisterCodeFix(new MyCodeAction( - title, - GetDocumentUpdater(context), - diagnosticId), context.Diagnostics); + context.RegisterCodeFix( + CodeAction.Create( + title, + GetDocumentUpdater(context), + diagnosticId), + context.Diagnostics); } protected override async Task FixAllAsync( @@ -131,14 +133,5 @@ private bool CanSimplifyTypeNameExpression(SemanticModel model, SyntaxNode node, return issueSpan.Equals(span); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction( - string title, Func> createChangedDocument, string equivalenceKey) - : base(title, createChangedDocument, equivalenceKey) - { - } - } } } diff --git a/src/Features/Core/Portable/SpellCheck/AbstractSpellCheckCodeFixProvider.cs b/src/Features/Core/Portable/SpellCheck/AbstractSpellCheckCodeFixProvider.cs index fb8cf487ab84c..cbae5d08d1fd3 100644 --- a/src/Features/Core/Portable/SpellCheck/AbstractSpellCheckCodeFixProvider.cs +++ b/src/Features/Core/Portable/SpellCheck/AbstractSpellCheckCodeFixProvider.cs @@ -187,7 +187,7 @@ private async Task CheckItemsAsync( { // Wrap the spell checking actions into a single top level suggestion // so as to not clutter the list. - context.RegisterCodeFix(new MyCodeAction( + context.RegisterCodeFix(new PriorityBasedCodeAction( string.Format(FeaturesResources.Fix_typo_0, nameText), codeActions), context.Diagnostics); } else @@ -235,11 +235,11 @@ public SpellCheckCodeAction(string title, Func } } - private class MyCodeAction : CodeAction.CodeActionWithNestedActions + private class PriorityBasedCodeAction : CodeAction.CodeActionWithNestedActions { internal override CodeActionPriority Priority => CodeActionPriority.Low; - public MyCodeAction(string title, ImmutableArray nestedActions) + public PriorityBasedCodeAction(string title, ImmutableArray nestedActions) : base(title, nestedActions, isInlinable: true) { } diff --git a/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs b/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs index 3d8631d648ae7..eb4449bc361fd 100644 --- a/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractMergeConsecutiveIfStatementsCodeRefactoringProvider.cs @@ -48,7 +48,8 @@ internal abstract class AbstractMergeConsecutiveIfStatementsCodeRefactoringProvi protected sealed override CodeAction CreateCodeAction(Func> createChangedDocument, MergeDirection direction, string ifKeywordText) { var resourceText = direction == MergeDirection.Up ? FeaturesResources.Merge_with_previous_0_statement : FeaturesResources.Merge_with_next_0_statement; - return new MyCodeAction(string.Format(resourceText, ifKeywordText), createChangedDocument); + var title = string.Format(resourceText, ifKeywordText); + return CodeAction.Create(title, createChangedDocument, title); } protected sealed override Task CanBeMergedUpAsync( @@ -255,13 +256,5 @@ private static bool ContainEquivalentStatements( statements = statements1; return statements1.SequenceEqual(statements2, syntaxFacts.AreEquivalent); } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs b/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs index c3c27ccde0435..2ae2eb4cc1a00 100644 --- a/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/SplitOrMergeIfStatements/Consecutive/AbstractSplitIntoConsecutiveIfStatementsCodeRefactoringProvider.cs @@ -46,7 +46,10 @@ protected sealed override int GetLogicalExpressionKind(ISyntaxKindsService synta => syntaxKinds.LogicalOrExpression; protected sealed override CodeAction CreateCodeAction(Func> createChangedDocument, string ifKeywordText) - => new MyCodeAction(string.Format(FeaturesResources.Split_into_consecutive_0_statements, ifKeywordText), createChangedDocument); + => CodeAction.Create( + string.Format(FeaturesResources.Split_into_consecutive_0_statements, ifKeywordText), + createChangedDocument, + nameof(FeaturesResources.Split_into_consecutive_0_statements) + ifKeywordText); protected sealed override async Task GetChangedRootAsync( Document document, @@ -151,13 +154,5 @@ private static async Task CanBeSeparateStatementsAsync( return !controlFlow.EndPointIsReachable; } } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractMergeNestedIfStatementsCodeRefactoringProvider.cs b/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractMergeNestedIfStatementsCodeRefactoringProvider.cs index 6532a17def714..d1cba7d22384c 100644 --- a/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractMergeNestedIfStatementsCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractMergeNestedIfStatementsCodeRefactoringProvider.cs @@ -36,7 +36,8 @@ internal abstract class AbstractMergeNestedIfStatementsCodeRefactoringProvider protected sealed override CodeAction CreateCodeAction(Func> createChangedDocument, MergeDirection direction, string ifKeywordText) { var resourceText = direction == MergeDirection.Up ? FeaturesResources.Merge_with_outer_0_statement : FeaturesResources.Merge_with_nested_0_statement; - return new MyCodeAction(string.Format(resourceText, ifKeywordText), createChangedDocument); + var title = string.Format(resourceText, ifKeywordText); + return CodeAction.Create(title, createChangedDocument, title); } protected sealed override Task CanBeMergedUpAsync( @@ -257,13 +258,5 @@ private static bool IsElseIfOrElseClauseEquivalent( return statements1.SequenceEqual(statements2, syntaxFacts.AreEquivalent); } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractSplitIntoNestedIfStatementsCodeRefactoringProvider.cs b/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractSplitIntoNestedIfStatementsCodeRefactoringProvider.cs index f7b3c45295fae..38bcabda1c90d 100644 --- a/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractSplitIntoNestedIfStatementsCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/SplitOrMergeIfStatements/Nested/AbstractSplitIntoNestedIfStatementsCodeRefactoringProvider.cs @@ -32,7 +32,10 @@ protected sealed override int GetLogicalExpressionKind(ISyntaxKindsService synta => syntaxKinds.LogicalAndExpression; protected sealed override CodeAction CreateCodeAction(Func> createChangedDocument, string ifKeywordText) - => new MyCodeAction(string.Format(FeaturesResources.Split_into_nested_0_statements, ifKeywordText), createChangedDocument); + => CodeAction.Create( + string.Format(FeaturesResources.Split_into_nested_0_statements, ifKeywordText), + createChangedDocument, + nameof(FeaturesResources.Split_into_nested_0_statements) + ifKeywordText); protected sealed override Task GetChangedRootAsync( Document document, @@ -53,13 +56,5 @@ protected sealed override Task GetChangedRootAsync( return Task.FromResult( root.ReplaceNode(ifOrElseIf, outerIfOrElseIf.WithAdditionalAnnotations(Formatter.Annotation))); } - - private sealed class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs b/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs index 3a8125dc5b72e..e83ea1c2b4bf9 100644 --- a/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs +++ b/src/Features/Core/Portable/UseNamedArguments/AbstractUseNamedArgumentsCodeRefactoringProvider.cs @@ -111,23 +111,26 @@ public async Task ComputeRefactoringsAsync( potentialArgumentsToName > 1) { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( string.Format(FeaturesResources.Add_argument_name_0, argumentName), - c => AddNamedArgumentsAsync(root, document, argument, parameters, argumentIndex, includingTrailingArguments: false)), + c => AddNamedArgumentsAsync(root, document, argument, parameters, argumentIndex, includingTrailingArguments: false), + nameof(FeaturesResources.Add_argument_name_0)), argument.Span); context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( string.Format(FeaturesResources.Add_argument_name_0_including_trailing_arguments, argumentName), - c => AddNamedArgumentsAsync(root, document, argument, parameters, argumentIndex, includingTrailingArguments: true)), + c => AddNamedArgumentsAsync(root, document, argument, parameters, argumentIndex, includingTrailingArguments: true), + nameof(FeaturesResources.Add_argument_name_0_including_trailing_arguments)), argument.Span); } else { context.RegisterRefactoring( - new MyCodeAction( + CodeAction.Create( string.Format(FeaturesResources.Add_argument_name_0, argumentName), - c => AddNamedArgumentsAsync(root, document, argument, parameters, argumentIndex, includingTrailingArguments: true)), + c => AddNamedArgumentsAsync(root, document, argument, parameters, argumentIndex, includingTrailingArguments: true), + nameof(FeaturesResources.Add_argument_name_0)), argument.Span); } } @@ -211,13 +214,5 @@ public sealed override async Task ComputeRefactoringsAsync(CodeRefactoringContex await _attributeArgumentAnalyzer.ComputeRefactoringsAsync(context, root).ConfigureAwait(false); } } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(string title, Func> createChangedDocument) - : base(title, createChangedDocument, title) - { - } - } } } diff --git a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEndConstruct/GenerateEndConstructCodeFixProvider.vb b/src/Features/VisualBasic/Portable/CodeFixes/GenerateEndConstruct/GenerateEndConstructCodeFixProvider.vb index 6ce7418cb3269..b3560b6cf596a 100644 --- a/src/Features/VisualBasic/Portable/CodeFixes/GenerateEndConstruct/GenerateEndConstructCodeFixProvider.vb +++ b/src/Features/VisualBasic/Portable/CodeFixes/GenerateEndConstruct/GenerateEndConstructCodeFixProvider.vb @@ -82,9 +82,10 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEndConstruct If endStatement.Parent.Kind = SyntaxKind.PropertyBlock Then context.RegisterCodeFix( - New MyCodeAction( + CodeAction.Create( VBFeaturesResources.Insert_the_missing_End_Property_statement, - Function(c) GeneratePropertyEndConstructAsync(context.Document, DirectCast(endStatement.Parent, PropertyBlockSyntax), c)), + Function(c) GeneratePropertyEndConstructAsync(context.Document, DirectCast(endStatement.Parent, PropertyBlockSyntax), c), + NameOf(VBFeaturesResources.Insert_the_missing_End_Property_statement)), context.Diagnostics) Return End If @@ -92,18 +93,21 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEndConstruct If endStatement.Kind = SyntaxKind.EndGetStatement OrElse endStatement.Kind = SyntaxKind.EndSetStatement Then If endStatement?.Parent?.Parent.Kind = SyntaxKind.PropertyBlock Then context.RegisterCodeFix( - New MyCodeAction( + CodeAction.Create( VBFeaturesResources.Insert_the_missing_End_Property_statement, - Function(c) GeneratePropertyEndConstructAsync(context.Document, DirectCast(endStatement.Parent.Parent, PropertyBlockSyntax), c)), + Function(c) GeneratePropertyEndConstructAsync(context.Document, DirectCast(endStatement.Parent.Parent, PropertyBlockSyntax), c), + NameOf(VBFeaturesResources.Insert_the_missing_End_Property_statement)), context.Diagnostics) Return End If End If + Dim title = GetDescription(endStatement) context.RegisterCodeFix( - New MyCodeAction( - GetDescription(endStatement), - Function(c) GenerateEndConstructAsync(context.Document, endStatement, c)), + CodeAction.Create( + title, + Function(c) GenerateEndConstructAsync(context.Document, endStatement, c), + title), context.Diagnostics) End Function @@ -254,13 +258,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.GenerateEndConstruct Return updatedDocument End Function - - Private Class MyCodeAction - Inherits CodeAction.DocumentChangeAction - - Public Sub New(title As String, createChangedDocument As Func(Of CancellationToken, Task(Of Document))) - MyBase.New(title, createChangedDocument, title) - End Sub - End Class End Class End Namespace diff --git a/src/Features/VisualBasic/Portable/CodeFixes/IncorrectFunctionReturnType/IncorrectFunctionReturnTypeCodeFixProvider.vb b/src/Features/VisualBasic/Portable/CodeFixes/IncorrectFunctionReturnType/IncorrectFunctionReturnTypeCodeFixProvider.vb index 65154b371977c..aaefe83490467 100644 --- a/src/Features/VisualBasic/Portable/CodeFixes/IncorrectFunctionReturnType/IncorrectFunctionReturnTypeCodeFixProvider.vb +++ b/src/Features/VisualBasic/Portable/CodeFixes/IncorrectFunctionReturnType/IncorrectFunctionReturnTypeCodeFixProvider.vb @@ -80,18 +80,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeFixes.IncorrectFunctionReturnTy Dim root = Await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(False) Dim newRoot = root.ReplaceNode(node, rewrittenNode) Dim newDocument = document.WithSyntaxRoot(newRoot) - Return {New MyCodeAction(newDocument)} + Return {CodeAction.Create( + VBFeaturesResources.Fix_Incorrect_Function_Return_Type, + Function(c) Task.FromResult(newDocument), + NameOf(VBFeaturesResources.Fix_Incorrect_Function_Return_Type))} End If Return SpecializedCollections.EmptyEnumerable(Of CodeAction)() End Function - - Private Class MyCodeAction - Inherits CodeAction.DocumentChangeAction - - Public Sub New(newDocument As Document) - MyBase.New(VBFeaturesResources.Fix_Incorrect_Function_Return_Type, Function(c) Task.FromResult(newDocument), NameOf(VBFeaturesResources.Fix_Incorrect_Function_Return_Type)) - End Sub - End Class End Class End Namespace diff --git a/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/VisualBasicInlineTemporaryCodeRefactoringProvider.vb b/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/VisualBasicInlineTemporaryCodeRefactoringProvider.vb index 7317a24165387..a3043da8e5451 100644 --- a/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/VisualBasicInlineTemporaryCodeRefactoringProvider.vb +++ b/src/Features/VisualBasic/Portable/CodeRefactorings/InlineTemporary/VisualBasicInlineTemporaryCodeRefactoringProvider.vb @@ -60,7 +60,11 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.InlineTemporary End If context.RegisterRefactoring( - New MyCodeAction(Function(c) InlineTemporaryAsync(document, modifiedIdentifier, c)), variableDeclarator.Span) + CodeAction.Create( + VBFeaturesResources.Inline_temporary_variable, + Function(c) InlineTemporaryAsync(document, modifiedIdentifier, c), + NameOf(VBFeaturesResources.Inline_temporary_variable)), + variableDeclarator.Span) End Function Private Shared Function HasConflict( @@ -465,13 +469,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.CodeRefactorings.InlineTemporary Return Await inlinedDocument.ReplaceNodesAsync(replacementNodesWithChangedSemantics.Keys, conflictAnnotationAdder, cancellationToken).ConfigureAwait(False) End Function - - Private Class MyCodeAction - Inherits CodeAction.DocumentChangeAction - - Public Sub New(createChangedDocument As Func(Of CancellationToken, Task(Of Document))) - MyBase.New(VBFeaturesResources.Inline_temporary_variable, createChangedDocument, NameOf(VBFeaturesResources.Inline_temporary_variable)) - End Sub - End Class End Class End Namespace diff --git a/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb b/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb index 0ee93c6e31214..826fe2f44ecfa 100644 --- a/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb +++ b/src/Features/VisualBasic/Portable/RemoveSharedFromModuleMembers/VisualBasicRemoveSharedFromModuleMembersCodeFixProvider.vb @@ -48,7 +48,12 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveSharedFromModuleMembers Continue For End If - context.RegisterCodeFix(New MyCodeAction(GetDocumentUpdater(context, diagnostic)), diagnostic) + context.RegisterCodeFix( + CodeAction.Create( + VBFeaturesResources.Remove_shared_keyword_from_module_member, + GetDocumentUpdater(context, diagnostic), + NameOf(VBFeaturesResources.Remove_shared_keyword_from_module_member)), + diagnostic) Next Return Task.CompletedTask @@ -68,13 +73,5 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.RemoveSharedFromModuleMembers Dim generator = SyntaxGenerator.GetGenerator(document) Return generator.WithModifiers(node, generator.GetModifiers(node).WithIsStatic(False)) End Function - - Private Class MyCodeAction - Inherits CodeAction.DocumentChangeAction - - Public Sub New(createChangedDocument As Func(Of CancellationToken, Task(Of Document))) - MyBase.New(VBFeaturesResources.Remove_shared_keyword_from_module_member, createChangedDocument, VBFeaturesResources.Remove_shared_keyword_from_module_member) - End Sub - End Class End Class End Namespace diff --git a/src/VisualStudio/Xaml/Impl/CodeFixes/RemoveUnnecessaryUsings/XamlRemoveUnnecessaryUsingsCodeFixProvider.cs b/src/VisualStudio/Xaml/Impl/CodeFixes/RemoveUnnecessaryUsings/XamlRemoveUnnecessaryUsingsCodeFixProvider.cs index d8c0595fa4bbd..b7e2ec4d64e8d 100644 --- a/src/VisualStudio/Xaml/Impl/CodeFixes/RemoveUnnecessaryUsings/XamlRemoveUnnecessaryUsingsCodeFixProvider.cs +++ b/src/VisualStudio/Xaml/Impl/CodeFixes/RemoveUnnecessaryUsings/XamlRemoveUnnecessaryUsingsCodeFixProvider.cs @@ -45,8 +45,10 @@ public override FixAllProvider GetFixAllProvider() public sealed override Task RegisterCodeFixesAsync(CodeFixContext context) { context.RegisterCodeFix( - new MyCodeAction( - c => RemoveUnnecessaryImportsAsync(context.Document, c)), + CodeAction.Create( + Resources.RemoveUnnecessaryNamespaces, + c => RemoveUnnecessaryImportsAsync(context.Document, c), + nameof(Resources.RemoveUnnecessaryNamespaces)), context.Diagnostics); return Task.CompletedTask; } @@ -57,13 +59,5 @@ private static async Task RemoveUnnecessaryImportsAsync( var service = document.GetLanguageService(); return await service.RemoveUnnecessaryImportsAsync(document, formattingOptions: null, cancellationToken).ConfigureAwait(false); } - - private class MyCodeAction : CodeAction.DocumentChangeAction - { - public MyCodeAction(Func> createChangedDocument) - : base(Resources.RemoveUnnecessaryNamespaces, createChangedDocument, nameof(Resources.RemoveUnnecessaryNamespaces)) - { - } - } } }