Extra telemetry for codefixes (#15035)

vsintegration/src/FSharp.Editor/CodeFix/AddInstanceMemberParameter.fs

@@ -8,7 +8,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "AddInstanceMemberParameter"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.AddInstanceMemberParameter); Shared>]
 type internal FSharpAddInstanceMemberParameterCodeFixProvider() =
     inherit CodeFixProvider()
 
@@ -27,6 +27,7 @@ type internal FSharpAddInstanceMemberParameterCodeFixProvider() =
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.AddInstanceMemberParameter,
                     title,
                     context,
                     (fun () -> asyncMaybe.Return [| TextChange(TextSpan(context.Span.Start, 0), "x.") |])

vsintegration/src/FSharp.Editor/CodeFix/AddMissingEqualsToTypeDefinition.fs

@@ -6,12 +6,10 @@ open System
 open System.Composition
 open System.Threading.Tasks
 
-open Microsoft.VisualStudio.FSharp.Editor.Logging
-
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "AddMissingEqualsToTypeDefinition"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.AddMissingEqualsToTypeDefinition); Shared>]
 type internal FSharpAddMissingEqualsToTypeDefinitionCodeFixProvider() =
     inherit CodeFixProvider()
 
@@ -43,6 +41,7 @@ type internal FSharpAddMissingEqualsToTypeDefinitionCodeFixProvider() =
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.AddMissingEqualsToTypeDefinition,
                     title,
                     context,
                     // 'pos + 1' is here because 'pos' is now the position of the first non-whitespace character.

vsintegration/src/FSharp.Editor/CodeFix/AddMissingFunKeyword.fs

@@ -11,7 +11,7 @@ open Microsoft.CodeAnalysis.CodeFixes
 open FSharp.Compiler
 open FSharp.Compiler.CodeAnalysis
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "AddMissingFunKeyword"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.AddMissingFunKeyword); Shared>]
 type internal FSharpAddMissingFunKeywordCodeFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -65,6 +65,7 @@ type internal FSharpAddMissingFunKeywordCodeFixProvider [<ImportingConstructor>]
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.AddMissingFunKeyword,
                     title,
                     context,
                     (fun () -> asyncMaybe.Return [| TextChange(TextSpan(intendedArgSpan.Start, 0), "fun ") |])

vsintegration/src/FSharp.Editor/CodeFix/AddNewKeywordToDisposableConstructorInvocation.fs

@@ -8,7 +8,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "AddNewKeyword"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.AddNewKeyword); Shared>]
 type internal FSharpAddNewKeywordCodeFixProvider() =
     inherit CodeFixProvider()
 
@@ -27,6 +27,7 @@ type internal FSharpAddNewKeywordCodeFixProvider() =
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.AddNewKeyword,
                     title,
                     context,
                     (fun () -> asyncMaybe.Return [| TextChange(TextSpan(context.Span.Start, 0), "new ") |])

vsintegration/src/FSharp.Editor/CodeFix/AddOpenCodeFixProvider.fs

@@ -17,7 +17,7 @@ open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.EditorServices
 open FSharp.Compiler.Text
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "AddOpen"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.AddOpen); Shared>]
 type internal FSharpAddOpenCodeFixProvider [<ImportingConstructor>] (assemblyContentProvider: AssemblyContentProvider) =
     inherit CodeFixProvider()
 
@@ -27,6 +27,7 @@ type internal FSharpAddOpenCodeFixProvider [<ImportingConstructor>] (assemblyCon
 
     let qualifySymbolFix (context: CodeFixContext) (fullName, qualifier) =
         CodeFixHelpers.createTextChangeCodeFix (
+            CodeFix.AddOpen,
             fixUnderscoresInMenuText fullName,
             context,
             (fun () -> asyncMaybe.Return [| TextChange(context.Span, qualifier) |])

vsintegration/src/FSharp.Editor/CodeFix/ChangePrefixNegationToInfixSubtraction.fs

@@ -9,7 +9,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ChangePrefixNegationToInfixSubtraction"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ChangePrefixNegationToInfixSubtraction); Shared>]
 type internal FSharpChangePrefixNegationToInfixSubtractionodeFixProvider() =
     inherit CodeFixProvider()
 
@@ -44,6 +44,7 @@ type internal FSharpChangePrefixNegationToInfixSubtractionodeFixProvider() =
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.ChangePrefixNegationToInfixSubtraction,
                     title,
                     context,
                     (fun () -> asyncMaybe.Return [| TextChange(TextSpan(pos, 1), "- ") |])

vsintegration/src/FSharp.Editor/CodeFix/ChangeRefCellDerefToNotExpression.fs

@@ -8,7 +8,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ChangeRefCellDerefToNotExpression"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ChangeRefCellDerefToNotExpression); Shared>]
 type internal FSharpChangeRefCellDerefToNotExpressionCodeFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -40,7 +40,12 @@ type internal FSharpChangeRefCellDerefToNotExpressionCodeFixProvider [<Importing
                 |> Seq.toImmutableArray
 
             let codeFix =
-                CodeFixHelpers.createTextChangeCodeFix (title, context, (fun () -> asyncMaybe.Return [| TextChange(derefSpan, "not ") |]))
+                CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.ChangeRefCellDerefToNotExpression,
+                    title,
+                    context,
+                    (fun () -> asyncMaybe.Return [| TextChange(derefSpan, "not ") |])
+                )
 
             context.RegisterCodeFix(codeFix, diagnostics)
         }

vsintegration/src/FSharp.Editor/CodeFix/ChangeToUpcast.fs

@@ -8,7 +8,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ChangeToUpcast"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ChangeToUpcast); Shared>]
 type internal FSharpChangeToUpcastCodeFixProvider() =
     inherit CodeFixProvider()
 
@@ -50,6 +50,7 @@ type internal FSharpChangeToUpcastCodeFixProvider() =
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.ChangeToUpcast,
                     title,
                     context,
                     (fun () -> asyncMaybe.Return [| TextChange(context.Span, replacement) |])

vsintegration/src/FSharp.Editor/CodeFix/CodeFixHelpers.fs

@@ -11,9 +11,22 @@ open Microsoft.VisualStudio.FSharp.Editor.Telemetry
 
 [<RequireQualifiedAccess>]
 module internal CodeFixHelpers =
-    let createTextChangeCodeFix (title: string, context: CodeFixContext, computeTextChanges: unit -> Async<TextChange[] option>) =
+    let createTextChangeCodeFix
+        (
+            name: string,
+            title: string,
+            context: CodeFixContext,
+            computeTextChanges: unit -> Async<TextChange[] option>
+        ) =
+
+        // I don't understand how we can get anything but a single diagnostic here - as we get a single "title" here.
+        // But since we don't have proper testing yet, keeping it like this to verify this theory in telemetry.
+        let ids = context.Diagnostics |> Seq.map (fun d -> d.Id) |> String.concat ","
+
         let props: (string * obj) list =
             [
+                "name", name
+                "ids", ids
                 "title", title
 
                 // The following can help building a unique but anonymized codefix target:
@@ -53,8 +66,8 @@ module internal CodeFixExtensions =
         member this.GetPrunedDiagnostics(context: CodeFixContext) =
             context.Diagnostics.RemoveAll(fun x -> this.FixableDiagnosticIds.Contains(x.Id) |> not)
 
-        member this.RegisterFix(context: CodeFixContext, fixName, fixChange) =
+        member this.RegisterFix(name, title, context: CodeFixContext, fixChange) =
             let replaceCodeFix =
-                CodeFixHelpers.createTextChangeCodeFix (fixName, context, (fun () -> asyncMaybe.Return [| fixChange |]))
+                CodeFixHelpers.createTextChangeCodeFix (name, title, context, (fun () -> asyncMaybe.Return [| fixChange |]))
 
             context.RegisterCodeFix(replaceCodeFix, this.GetPrunedDiagnostics(context))

vsintegration/src/FSharp.Editor/CodeFix/ConvertCSharpLambdaToFSharpLambda.fs

@@ -7,7 +7,7 @@ open System.Composition
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ConvertCSharpLambdaToFSharpLambda"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ConvertCSharpLambdaToFSharpLambda); Shared>]
 type internal FSharpConvertCSharpLambdaToFSharpLambdaCodeFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -46,7 +46,12 @@ type internal FSharpConvertCSharpLambdaToFSharpLambdaCodeFixProvider [<Importing
             let title = SR.UseFSharpLambda()
 
             let codeFix =
-                CodeFixHelpers.createTextChangeCodeFix (title, context, (fun () -> asyncMaybe.Return [| replacement |]))
+                CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.ConvertCSharpLambdaToFSharpLambda,
+                    title,
+                    context,
+                    (fun () -> asyncMaybe.Return [| replacement |])
+                )
 
             context.RegisterCodeFix(codeFix, diagnostics)
         }

vsintegration/src/FSharp.Editor/CodeFix/ConvertCSharpUsingToFSharpOpen.fs

@@ -10,7 +10,7 @@ open Microsoft.CodeAnalysis
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ConvertCSharpUsingToFSharpOpen"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ConvertCSharpUsingToFSharpOpen); Shared>]
 type internal FSharpConvertCSharpUsingToFSharpOpen [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -47,7 +47,12 @@ type internal FSharpConvertCSharpUsingToFSharpOpen [<ImportingConstructor>] () =
         let title = SR.ConvertCSharpUsingToFSharpOpen()
 
         let codeFix =
-            CodeFixHelpers.createTextChangeCodeFix (title, context, (fun () -> asyncMaybe.Return [| replacement |]))
+            CodeFixHelpers.createTextChangeCodeFix (
+                CodeFix.ConvertCSharpUsingToFSharpOpen,
+                title,
+                context,
+                (fun () -> asyncMaybe.Return [| replacement |])
+            )
 
         context.RegisterCodeFix(codeFix, diagnostics)
 

vsintegration/src/FSharp.Editor/CodeFix/ConvertToNotEqualsEqualityExpression.fs

@@ -8,7 +8,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ConvertToNotEqualsEqualityExpression"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ConvertToNotEqualsEqualityExpression); Shared>]
 type internal FSharpConvertToNotEqualsEqualityExpressionCodeFixProvider() =
     inherit CodeFixProvider()
 
@@ -33,7 +33,12 @@ type internal FSharpConvertToNotEqualsEqualityExpressionCodeFixProvider() =
                 |> Seq.toImmutableArray
 
             let codeFix =
-                CodeFixHelpers.createTextChangeCodeFix (title, context, (fun () -> asyncMaybe.Return [| TextChange(context.Span, "<>") |]))
+                CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.ConvertToNotEqualsEqualityExpression,
+                    title,
+                    context,
+                    (fun () -> asyncMaybe.Return [| TextChange(context.Span, "<>") |])
+                )
 
             context.RegisterCodeFix(codeFix, diagnostics)
         }

vsintegration/src/FSharp.Editor/CodeFix/ConvertToSingleEqualsEqualityExpression.fs

@@ -8,7 +8,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ConvertToSingleEqualsEqualityExpression"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ConvertToSingleEqualsEqualityExpression); Shared>]
 type internal FSharpConvertToSingleEqualsEqualityExpressionCodeFixProvider() =
     inherit CodeFixProvider()
 
@@ -33,7 +33,12 @@ type internal FSharpConvertToSingleEqualsEqualityExpressionCodeFixProvider() =
                 |> Seq.toImmutableArray
 
             let codeFix =
-                CodeFixHelpers.createTextChangeCodeFix (title, context, (fun () -> asyncMaybe.Return [| TextChange(context.Span, "=") |]))
+                CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.ConvertToSingleEqualsEqualityExpression,
+                    title,
+                    context,
+                    (fun () -> asyncMaybe.Return [| TextChange(context.Span, "=") |])
+                )
 
             context.RegisterCodeFix(codeFix, diagnostics)
         }

vsintegration/src/FSharp.Editor/CodeFix/FixIndexerAccess.fs

@@ -10,7 +10,7 @@ open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 open FSharp.Compiler.Diagnostics
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "FixIndexerAccess"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.FixIndexerAccess); Shared>]
 type internal LegacyFsharpFixAddDotToIndexerAccess() =
     inherit CodeFixProvider()
     let fixableDiagnosticIds = set [ "FS3217" ]
@@ -49,6 +49,7 @@ type internal LegacyFsharpFixAddDotToIndexerAccess() =
 
                     let codefix =
                         CodeFixHelpers.createTextChangeCodeFix (
+                            CodeFix.FixIndexerAccess,
                             CompilerDiagnostics.GetErrorMessage FSharpDiagnosticKind.AddIndexerDot,
                             context,
                             (fun () -> asyncMaybe.Return [| TextChange(span, replacement.TrimEnd() + ".") |])
@@ -58,12 +59,12 @@ type internal LegacyFsharpFixAddDotToIndexerAccess() =
         }
         |> RoslynHelpers.StartAsyncUnitAsTask(context.CancellationToken)
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "RemoveIndexerDotBeforeBracket"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.RemoveIndexerDotBeforeBracket); Shared>]
 type internal FsharpFixRemoveDotFromIndexerAccessOptIn() as this =
     inherit CodeFixProvider()
     let fixableDiagnosticIds = set [ "FS3366" ]
 
-    static let fixName =
+    static let title =
         CompilerDiagnostics.GetErrorMessage FSharpDiagnosticKind.RemoveIndexerDot
 
     override _.FixableDiagnosticIds = Seq.toImmutableArray fixableDiagnosticIds
@@ -73,5 +74,5 @@ type internal FsharpFixRemoveDotFromIndexerAccessOptIn() as this =
             let relevantDiagnostics = this.GetPrunedDiagnostics(context)
 
             if not relevantDiagnostics.IsEmpty then
-                this.RegisterFix(context, fixName, TextChange(context.Span, ""))
+                this.RegisterFix(CodeFix.RemoveIndexerDotBeforeBracket, title, context, TextChange(context.Span, ""))
         }

vsintegration/src/FSharp.Editor/CodeFix/MakeDeclarationMutable.fs

@@ -3,18 +3,15 @@
 namespace Microsoft.VisualStudio.FSharp.Editor
 
 open System.Composition
-open System.Threading
 open System.Threading.Tasks
 
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-open FSharp.Compiler
-open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.EditorServices
 open FSharp.Compiler.Text
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "MakeDeclarationMutable"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.MakeDeclarationMutable); Shared>]
 type internal FSharpMakeDeclarationMutableFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -73,6 +70,7 @@ type internal FSharpMakeDeclarationMutableFixProvider [<ImportingConstructor>] (
 
                 let codeFix =
                     CodeFixHelpers.createTextChangeCodeFix (
+                        CodeFix.MakeDeclarationMutable,
                         title,
                         context,
                         (fun () -> asyncMaybe.Return [| TextChange(TextSpan(span.Start, 0), "mutable ") |])

vsintegration/src/FSharp.Editor/CodeFix/MakeOuterBindingRecursive.fs

@@ -8,7 +8,7 @@ open System.Composition
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "MakeOuterBindingRecursive"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.MakeOuterBindingRecursive); Shared>]
 type internal FSharpMakeOuterBindingRecursiveCodeFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -50,6 +50,7 @@ type internal FSharpMakeOuterBindingRecursiveCodeFixProvider [<ImportingConstruc
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.MakeOuterBindingRecursive,
                     title,
                     context,
                     (fun () -> asyncMaybe.Return [| TextChange(TextSpan(outerBindingNameSpan.Start, 0), "rec ") |])

vsintegration/src/FSharp.Editor/CodeFix/RemoveReturnOrYield.fs

@@ -7,7 +7,7 @@ open System.Composition
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "RemoveReturnOrYield"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.RemoveReturnOrYield); Shared>]
 type internal FSharpRemoveReturnOrYieldCodeFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -44,6 +44,7 @@ type internal FSharpRemoveReturnOrYieldCodeFixProvider [<ImportingConstructor>]
 
             let codeFix =
                 CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.RemoveReturnOrYield,
                     title,
                     context,
                     (fun () -> asyncMaybe.Return [| TextChange(context.Span, sourceText.GetSubText(exprSpan).ToString()) |])

vsintegration/src/FSharp.Editor/CodeFix/RemoveSuperflousCaptureForUnionCaseWithNoData.fs

@@ -2,20 +2,15 @@
 
 namespace Microsoft.VisualStudio.FSharp.Editor
 
-open System
 open System.Composition
 open System.Threading.Tasks
 
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-open FSharp.Compiler
-open FSharp.Compiler.CodeAnalysis
-open FSharp.Compiler.Symbols
-open FSharp.Compiler.Syntax
 open FSharp.Compiler.EditorServices
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "RemoveSuperflousCapture"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.RemoveSuperfluousCapture); Shared>]
 type internal RemoveSuperflousCaptureForUnionCaseWithNoDataProvider [<ImportingConstructor>] () =
 
     inherit CodeFixProvider()
@@ -51,7 +46,7 @@ type internal RemoveSuperflousCaptureForUnionCaseWithNoDataProvider [<ImportingC
                 let reminderSpan =
                     new TextSpan(context.Span.Start + typeInfoLength, context.Span.Length - typeInfoLength)
 
-                this.RegisterFix(context, SR.RemoveUnusedBinding(), TextChange(reminderSpan, ""))
+                this.RegisterFix(CodeFix.RemoveSuperfluousCapture, SR.RemoveUnusedBinding(), context, TextChange(reminderSpan, ""))
         }
         |> Async.Ignore
         |> RoslynHelpers.StartAsyncUnitAsTask(context.CancellationToken)

vsintegration/src/FSharp.Editor/CodeFix/RemoveUnusedBinding.fs

@@ -9,7 +9,7 @@ open System.Threading.Tasks
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "RemoveUnusedBinding"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.RemoveUnusedBinding); Shared>]
 type internal FSharpRemoveUnusedBindingCodeFixProvider [<ImportingConstructor>] () =
 
     inherit CodeFixProvider()
@@ -57,7 +57,12 @@ type internal FSharpRemoveUnusedBindingCodeFixProvider [<ImportingConstructor>]
             let prefixTitle = SR.RemoveUnusedBinding()
 
             let removalCodeFix =
-                CodeFixHelpers.createTextChangeCodeFix (prefixTitle, context, (fun () -> asyncMaybe.Return [| TextChange(fullSpan, "") |]))
+                CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.RemoveUnusedBinding,
+                    prefixTitle,
+                    context,
+                    (fun () -> asyncMaybe.Return [| TextChange(fullSpan, "") |])
+                )
 
             context.RegisterCodeFix(removalCodeFix, diagnostics)
         }

vsintegration/src/FSharp.Editor/CodeFix/RemoveUnusedOpens.fs

@@ -11,7 +11,7 @@ open Microsoft.CodeAnalysis.ExternalAccess.FSharp.Diagnostics
 
 open FSharp.Compiler.Text
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "RemoveUnusedOpens"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.RemoveUnusedOpens); Shared>]
 type internal FSharpRemoveUnusedOpensCodeFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -41,7 +41,7 @@ type internal FSharpRemoveUnusedOpensCodeFixProvider [<ImportingConstructor>] ()
             let title = SR.RemoveUnusedOpens()
 
             let codefix =
-                CodeFixHelpers.createTextChangeCodeFix (title, context, (fun () -> asyncMaybe.Return changes))
+                CodeFixHelpers.createTextChangeCodeFix (CodeFix.RemoveUnusedOpens, title, context, (fun () -> asyncMaybe.Return changes))
 
             context.RegisterCodeFix(codefix, diagnostics)
         }

vsintegration/src/FSharp.Editor/CodeFix/RenameParamToMatchSignature.fs

@@ -13,7 +13,7 @@ open Microsoft.VisualStudio.FSharp.Editor.SymbolHelpers
 open FSharp.Compiler.Diagnostics
 open FSharp.Compiler.Tokenization.FSharpKeywords
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "FSharpRenameParamToMatchSignature"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.FSharpRenameParamToMatchSignature); Shared>]
 type internal FSharpRenameParamToMatchSignature [<ImportingConstructor>] () =
 
     inherit CodeFixProvider()
@@ -65,7 +65,7 @@ type internal FSharpRenameParamToMatchSignature [<ImportingConstructor>] () =
                         CompilerDiagnostics.GetErrorMessage(FSharpDiagnosticKind.ReplaceWithSuggestion suggestion)
 
                     let codefix =
-                        CodeFixHelpers.createTextChangeCodeFix (title, context, computeChanges)
+                        CodeFixHelpers.createTextChangeCodeFix (CodeFix.FSharpRenameParamToMatchSignature, title, context, computeChanges)
 
                     context.RegisterCodeFix(codefix, diagnostics)
             | _ -> ()

vsintegration/src/FSharp.Editor/CodeFix/RenameUnusedValue.fs

@@ -14,7 +14,7 @@ open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Symbols
 open FSharp.Compiler.Syntax
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "RenameUnusedValue"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.RenameUnusedValue); Shared>]
 type internal FSharpRenameUnusedValueCodeFixProvider [<ImportingConstructor>] () =
 
     inherit CodeFixProvider()
@@ -67,6 +67,7 @@ type internal FSharpRenameUnusedValueCodeFixProvider [<ImportingConstructor>] ()
 
                     let prefixCodeFix =
                         CodeFixHelpers.createTextChangeCodeFix (
+                            CodeFix.RenameUnusedValue,
                             prefixTitle,
                             context,
                             (fun () -> asyncMaybe.Return [| TextChange(TextSpan(context.Span.Start, 0), "_") |])
@@ -79,6 +80,7 @@ type internal FSharpRenameUnusedValueCodeFixProvider [<ImportingConstructor>] ()
 
                         let replaceCodeFix =
                             CodeFixHelpers.createTextChangeCodeFix (
+                                CodeFix.RenameUnusedValue,
                                 replaceTitle,
                                 context,
                                 (fun () -> asyncMaybe.Return [| TextChange(context.Span, "_") |])

vsintegration/src/FSharp.Editor/CodeFix/ReplaceWithSuggestion.fs

@@ -14,7 +14,7 @@ open FSharp.Compiler.Syntax
 open FSharp.Compiler.Text
 open FSharp.Compiler.Tokenization
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "ReplaceWithSuggestion"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.ReplaceWithSuggestion); Shared>]
 type internal FSharpReplaceWithSuggestionCodeFixProvider [<ImportingConstructor>] (settings: EditorOptions) =
     inherit CodeFixProvider()
 
@@ -61,6 +61,7 @@ type internal FSharpReplaceWithSuggestionCodeFixProvider [<ImportingConstructor>
 
                 let codeFix =
                     CodeFixHelpers.createTextChangeCodeFix (
+                        CodeFix.ReplaceWithSuggestion,
                         CompilerDiagnostics.GetErrorMessage(FSharpDiagnosticKind.ReplaceWithSuggestion suggestion),
                         context,
                         (fun () -> asyncMaybe.Return [| TextChange(context.Span, replacement) |])

vsintegration/src/FSharp.Editor/CodeFix/SimplifyName.fs

@@ -10,7 +10,7 @@ open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 open Microsoft.CodeAnalysis.ExternalAccess.FSharp.Diagnostics
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "SimplifyNames"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.SimplifyName); Shared>]
 type internal FSharpSimplifyNameCodeFixProvider() =
     inherit CodeFixProvider()
     let fixableDiagnosticId = FSharpIDEDiagnosticIds.SimplifyNamesDiagnosticId
@@ -27,6 +27,7 @@ type internal FSharpSimplifyNameCodeFixProvider() =
 
                 let codefix =
                     CodeFixHelpers.createTextChangeCodeFix (
+                        CodeFix.SimplifyName,
                         title,
                         context,
                         (fun () -> asyncMaybe.Return [| TextChange(context.Span, "") |])

vsintegration/src/FSharp.Editor/CodeFix/UseMutationWhenValueIsMutable.fs

@@ -4,18 +4,15 @@ namespace Microsoft.VisualStudio.FSharp.Editor
 
 open System
 open System.Composition
-open System.Threading
 open System.Threading.Tasks
 
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-open FSharp.Compiler
-open FSharp.Compiler.CodeAnalysis
 open FSharp.Compiler.Symbols
 open FSharp.Compiler.Text
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "UseMutationWhenValueIsMutable"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.UseMutationWhenValueIsMutable); Shared>]
 type internal FSharpUseMutationWhenValueIsMutableFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -83,6 +80,7 @@ type internal FSharpUseMutationWhenValueIsMutableFixProvider [<ImportingConstruc
 
                 let codeFix =
                     CodeFixHelpers.createTextChangeCodeFix (
+                        CodeFix.UseMutationWhenValueIsMutable,
                         title,
                         context,
                         (fun () -> asyncMaybe.Return [| TextChange(TextSpan(pos + 1, 1), "<-") |])

vsintegration/src/FSharp.Editor/CodeFix/UseTripleQuotedInterpolation.fs

@@ -7,7 +7,7 @@ open System.Composition
 open Microsoft.CodeAnalysis.Text
 open Microsoft.CodeAnalysis.CodeFixes
 
-[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = "UseTripleQuotedInterpolation"); Shared>]
+[<ExportCodeFixProvider(FSharpConstants.FSharpLanguageName, Name = CodeFix.UseTripleQuotedInterpolation); Shared>]
 type internal FSharpUseTripleQuotedInterpolationCodeFixProvider [<ImportingConstructor>] () =
     inherit CodeFixProvider()
 
@@ -41,7 +41,12 @@ type internal FSharpUseTripleQuotedInterpolationCodeFixProvider [<ImportingConst
             let title = SR.UseTripleQuotedInterpolation()
 
             let codeFix =
-                CodeFixHelpers.createTextChangeCodeFix (title, context, (fun () -> asyncMaybe.Return [| replacement |]))
+                CodeFixHelpers.createTextChangeCodeFix (
+                    CodeFix.UseTripleQuotedInterpolation,
+                    title,
+                    context,
+                    (fun () -> asyncMaybe.Return [| replacement |])
+                )
 
             context.RegisterCodeFix(codeFix, diagnostics)
         }

vsintegration/src/FSharp.Editor/Common/Constants.fs

@@ -94,3 +94,86 @@ module internal Guids =
     let formattingOptionPageIdString = "9EBEBCE8-A79B-46B0-A8C5-A9818AEED17D"
 
     let blueHighContrastThemeId = Guid "{ce94d289-8481-498b-8ca9-9b6191a315b9}"
+
+[<RequireQualifiedAccess>]
+module internal CodeFix =
+
+    [<Literal>]
+    let AddInstanceMemberParameter = "AddInstanceMemberParameter"
+
+    [<Literal>]
+    let ConvertCSharpLambdaToFSharpLambda = "ConvertCSharpLambdaToFSharpLambda"
+
+    [<Literal>]
+    let ConvertToNotEqualsEqualityExpression = "ConvertToNotEqualsEqualityExpression"
+
+    [<Literal>]
+    let UseTripleQuotedInterpolation = "UseTripleQuotedInterpolation"
+
+    [<Literal>]
+    let SimplifyName = "SimplifyName"
+
+    [<Literal>]
+    let RemoveUnusedBinding = "RemoveUnusedBinding"
+
+    [<Literal>]
+    let ChangeToUpcast = "ChangeToUpcast"
+
+    [<Literal>]
+    let UseMutationWhenValueIsMutable = "UseMutationWhenValueIsMutable"
+
+    [<Literal>]
+    let RenameUnusedValue = "RenameUnusedValue"
+
+    [<Literal>]
+    let FixIndexerAccess = "FixIndexerAccess"
+
+    [<Literal>]
+    let RemoveReturnOrYield = "RemoveReturnOrYield"
+
+    [<Literal>]
+    let ReplaceWithSuggestion = "ReplaceWithSuggestion"
+
+    [<Literal>]
+    let MakeOuterBindingRecursive = "MakeOuterBindingRecursive"
+
+    [<Literal>]
+    let ConvertToSingleEqualsEqualityExpression =
+        "ConvertToSingleEqualsEqualityExpression"
+
+    [<Literal>]
+    let MakeDeclarationMutable = "MakeDeclarationMutable"
+
+    [<Literal>]
+    let ChangePrefixNegationToInfixSubtraction =
+        "ChangePrefixNegationToInfixSubtraction"
+
+    [<Literal>]
+    let AddMissingFunKeyword = "AddMissingFunKeyword"
+
+    [<Literal>]
+    let AddNewKeyword = "AddNewKeyword"
+
+    [<Literal>]
+    let RemoveUnusedOpens = "RemoveUnusedOpens"
+
+    [<Literal>]
+    let AddOpen = "AddOpen"
+
+    [<Literal>]
+    let ConvertCSharpUsingToFSharpOpen = "ConvertCSharpUsingToFSharpOpen"
+
+    [<Literal>]
+    let ChangeRefCellDerefToNotExpression = "ChangeRefCellDerefToNotExpression"
+
+    [<Literal>]
+    let AddMissingEqualsToTypeDefinition = "AddMissingEqualsToTypeDefinition"
+
+    [<Literal>]
+    let FSharpRenameParamToMatchSignature = "FSharpRenameParamToMatchSignature"
+
+    [<Literal>]
+    let RemoveIndexerDotBeforeBracket = "RemoveIndexerDotBeforeBracket"
+
+    [<Literal>]
+    let RemoveSuperfluousCapture = "RemoveSuperfluousCapture"