diff --git a/src/Analyzers/Core/Analyzers/AddRequiredParentheses/AbstractAddRequiredParenthesesDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/AddRequiredParentheses/AbstractAddRequiredParenthesesDiagnosticAnalyzer.cs
index 910a78bb03352..39b7d542014a7 100644
--- a/src/Analyzers/Core/Analyzers/AddRequiredParentheses/AbstractAddRequiredParenthesesDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/AddRequiredParentheses/AbstractAddRequiredParenthesesDiagnosticAnalyzer.cs
@@ -129,12 +129,13 @@ private void AddDiagnostics(
 
                 var properties = GetProperties(includeInFixAll, equivalenceKey);
 
-                context.ReportDiagnostic(DiagnosticHelper.Create(
+                DiagnosticHelper.CreateAndReportDiagnostic(
+                    context.ReportDiagnostic,
                     Descriptor,
                     operatorToken.GetLocation(),
                     severity,
                     additionalLocations,
-                    properties));
+                    properties);
 
                 // We're adding diagnostics for all subcomponents so that the user can get the
                 // lightbulb on any of the operator tokens.  However, we don't actually want to
diff --git a/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs
index 7a35d56bebdf5..86ef5febf002f 100644
--- a/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/ConvertTypeofToNameof/AbstractConvertTypeOfToNameOfDiagnosticAnalyzer.cs
@@ -50,12 +50,13 @@ protected void AnalyzeAction(OperationAnalysisContext context)
 
             var location = parent.GetLocation();
             var options = context.Compilation.Options;
-            context.ReportDiagnostic(
-                DiagnosticHelper.Create(Descriptor,
-                                        location,
-                                        Descriptor.GetEffectiveSeverity(options),
-                                        additionalLocations: null,
-                                        properties: null));
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
+                Descriptor,
+                location,
+                Descriptor.GetEffectiveSeverity(options),
+                additionalLocations: null,
+                properties: null);
 
         }
 
diff --git a/src/Analyzers/Core/Analyzers/ForEachCast/AbstractForEachCastDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/ForEachCast/AbstractForEachCastDiagnosticAnalyzer.cs
index 082f3d5c62975..dce6e5f350816 100644
--- a/src/Analyzers/Core/Analyzers/ForEachCast/AbstractForEachCastDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/ForEachCast/AbstractForEachCastDiagnosticAnalyzer.cs
@@ -127,7 +127,8 @@ protected void AnalyzeSyntax(
                 semanticModel.Compilation.GetBestTypeByMetadataName(typeof(Enumerable).FullName!) != null;
 
             var options = semanticModel.Compilation.Options;
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 node.GetFirstToken().GetLocation(),
                 option.Notification.Severity,
@@ -135,7 +136,7 @@ protected void AnalyzeSyntax(
                 properties: isFixable ? s_isFixableProperties : null,
                 node.GetFirstToken().ToString(),
                 collectionElementType.ToDisplayString(),
-                iterationType.ToDisplayString()));
+                iterationType.ToDisplayString());
         }
 
         private static bool IsStronglyTyped(INamedTypeSymbol ienumerableOfTType, ITypeSymbol collectionType, ITypeSymbol collectionElementType)
diff --git a/src/Analyzers/Core/Analyzers/Helpers/DiagnosticHelper.cs b/src/Analyzers/Core/Analyzers/Helpers/DiagnosticHelper.cs
index 36d5d9a48fb88..0be4ba885545b 100644
--- a/src/Analyzers/Core/Analyzers/Helpers/DiagnosticHelper.cs
+++ b/src/Analyzers/Core/Analyzers/Helpers/DiagnosticHelper.cs
@@ -17,6 +17,22 @@ namespace Microsoft.CodeAnalysis.Diagnostics
 {
     internal static class DiagnosticHelper
     {
+        public static void CreateAndReportDiagnostic(
+            Action<Diagnostic> reportDiagnostic,
+            DiagnosticDescriptor descriptor,
+            Location location,
+            ReportDiagnostic effectiveSeverity,
+            IEnumerable<Location>? additionalLocations,
+            ImmutableDictionary<string, string?>? properties,
+            params object[] messageArgs)
+        {
+            var diagnostic = Create(descriptor, location, effectiveSeverity, additionalLocations, properties, messageArgs);
+            if (diagnostic is not null)
+            {
+                reportDiagnostic(diagnostic);
+            }
+        }
+
         /// <summary>
         /// Creates a <see cref="Diagnostic"/> instance.
         /// </summary>
@@ -35,7 +51,7 @@ internal static class DiagnosticHelper
         /// </param>
         /// <param name="messageArgs">Arguments to the message of the diagnostic.</param>
         /// <returns>The <see cref="Diagnostic"/> instance.</returns>
-        public static Diagnostic Create(
+        private static Diagnostic? Create(
             DiagnosticDescriptor descriptor,
             Location location,
             ReportDiagnostic effectiveSeverity,
@@ -48,17 +64,28 @@ public static Diagnostic Create(
                 throw new ArgumentNullException(nameof(descriptor));
             }
 
-            LocalizableString message;
-            if (messageArgs == null || messageArgs.Length == 0)
+            if (effectiveSeverity == ReportDiagnostic.Suppress)
             {
-                message = descriptor.MessageFormat;
+                return null;
             }
-            else
+
+            return Diagnostic.Create(descriptor, location, effectiveSeverity.ToDiagnosticSeverity() ?? descriptor.DefaultSeverity, additionalLocations, properties, messageArgs);
+        }
+
+        public static void CreateWithLocationTagsAndReport(
+            Action<Diagnostic> reportDiagnostic,
+            DiagnosticDescriptor descriptor,
+            Location location,
+            ReportDiagnostic effectiveSeverity,
+            ImmutableArray<Location> additionalLocations,
+            ImmutableArray<Location> additionalUnnecessaryLocations,
+            params object[] messageArgs)
+        {
+            var diagnostic = CreateWithLocationTags(descriptor, location, effectiveSeverity, additionalLocations, additionalUnnecessaryLocations, messageArgs);
+            if (diagnostic is not null)
             {
-                message = new LocalizableStringWithArguments(descriptor.MessageFormat, messageArgs);
+                reportDiagnostic(diagnostic);
             }
-
-            return CreateWithMessage(descriptor, location, effectiveSeverity, additionalLocations, properties, message);
         }
 
         /// <summary>
@@ -80,7 +107,7 @@ public static Diagnostic Create(
         /// </param>
         /// <param name="messageArgs">Arguments to the message of the diagnostic.</param>
         /// <returns>The <see cref="Diagnostic"/> instance.</returns>
-        public static Diagnostic CreateWithLocationTags(
+        private static Diagnostic? CreateWithLocationTags(
             DiagnosticDescriptor descriptor,
             Location location,
             ReportDiagnostic effectiveSeverity,
@@ -105,6 +132,23 @@ public static Diagnostic CreateWithLocationTags(
                 messageArgs);
         }
 
+        public static void CreateWithLocationTagsAndReport(
+            Action<Diagnostic> reportDiagnostic,
+            DiagnosticDescriptor descriptor,
+            Location location,
+            ReportDiagnostic effectiveSeverity,
+            ImmutableArray<Location> additionalLocations,
+            ImmutableArray<Location> additionalUnnecessaryLocations,
+            ImmutableDictionary<string, string?> properties,
+            params object[] messageArgs)
+        {
+            var diagnostic = CreateWithLocationTags(descriptor, location, effectiveSeverity, additionalLocations, additionalUnnecessaryLocations, properties, messageArgs);
+            if (diagnostic is not null)
+            {
+                reportDiagnostic(diagnostic);
+            }
+        }
+
         /// <summary>
         /// Create a diagnostic that adds properties specifying a tag for a set of locations.
         /// </summary>
@@ -128,7 +172,7 @@ public static Diagnostic CreateWithLocationTags(
         /// </param>
         /// <param name="messageArgs">Arguments to the message of the diagnostic.</param>
         /// <returns>The <see cref="Diagnostic"/> instance.</returns>
-        public static Diagnostic CreateWithLocationTags(
+        private static Diagnostic? CreateWithLocationTags(
             DiagnosticDescriptor descriptor,
             Location location,
             ReportDiagnostic effectiveSeverity,
@@ -174,7 +218,7 @@ public static Diagnostic CreateWithLocationTags(
         /// </param>
         /// <param name="messageArgs">Arguments to the message of the diagnostic.</param>
         /// <returns>The <see cref="Diagnostic"/> instance.</returns>
-        private static Diagnostic CreateWithLocationTags(
+        private static Diagnostic? CreateWithLocationTags(
             DiagnosticDescriptor descriptor,
             Location location,
             ReportDiagnostic effectiveSeverity,
@@ -206,55 +250,6 @@ static string EncodeIndices(IEnumerable<int> indices, int additionalLocationsLen
             }
         }
 
-        /// <summary>
-        /// Creates a <see cref="Diagnostic"/> instance.
-        /// </summary>
-        /// <param name="descriptor">A <see cref="DiagnosticDescriptor"/> describing the diagnostic.</param>
-        /// <param name="location">An optional primary location of the diagnostic. If null, <see cref="Location"/> will return <see cref="Location.None"/>.</param>
-        /// <param name="effectiveSeverity">Effective severity of the diagnostic.</param>
-        /// <param name="additionalLocations">
-        /// An optional set of additional locations related to the diagnostic.
-        /// Typically, these are locations of other items referenced in the message.
-        /// If null, <see cref="Diagnostic.AdditionalLocations"/> will return an empty list.
-        /// </param>
-        /// <param name="properties">
-        /// An optional set of name-value pairs by means of which the analyzer that creates the diagnostic
-        /// can convey more detailed information to the fixer. If null, <see cref="Diagnostic.Properties"/> will return
-        /// <see cref="ImmutableDictionary{TKey, TValue}.Empty"/>.
-        /// </param>
-        /// <param name="message">Localizable message for the diagnostic.</param>
-        /// <returns>The <see cref="Diagnostic"/> instance.</returns>
-        public static Diagnostic CreateWithMessage(
-            DiagnosticDescriptor descriptor,
-            Location location,
-            ReportDiagnostic effectiveSeverity,
-            IEnumerable<Location>? additionalLocations,
-            ImmutableDictionary<string, string?>? properties,
-            LocalizableString message)
-        {
-            if (descriptor == null)
-            {
-                throw new ArgumentNullException(nameof(descriptor));
-            }
-
-            return Diagnostic.Create(
-                descriptor.Id,
-                descriptor.Category,
-                message,
-                effectiveSeverity.ToDiagnosticSeverity() ?? descriptor.DefaultSeverity,
-                descriptor.DefaultSeverity,
-                descriptor.IsEnabledByDefault,
-                warningLevel: effectiveSeverity.WithDefaultSeverity(descriptor.DefaultSeverity) == ReportDiagnostic.Error ? 0 : 1,
-                effectiveSeverity == ReportDiagnostic.Suppress,
-                descriptor.Title,
-                descriptor.Description,
-                descriptor.HelpLinkUri,
-                location,
-                additionalLocations,
-                descriptor.CustomTags,
-                properties);
-        }
-
         public static string? GetHelpLinkForDiagnosticId(string id)
         {
             // TODO: Add documentation for Regex and Json analyzer
@@ -268,90 +263,5 @@ public static Diagnostic CreateWithMessage(
             Debug.Assert(id.StartsWith("IDE", StringComparison.Ordinal));
             return $"https://docs.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/{id.ToLowerInvariant()}";
         }
-
-        public sealed class LocalizableStringWithArguments : LocalizableString, IObjectWritable
-        {
-            private readonly LocalizableString _messageFormat;
-            private readonly string[] _formatArguments;
-
-            static LocalizableStringWithArguments()
-                => ObjectBinder.RegisterTypeReader(typeof(LocalizableStringWithArguments), reader => new LocalizableStringWithArguments(reader));
-
-            public LocalizableStringWithArguments(LocalizableString messageFormat, params object[] formatArguments)
-            {
-                if (messageFormat == null)
-                {
-                    throw new ArgumentNullException(nameof(messageFormat));
-                }
-
-                if (formatArguments == null)
-                {
-                    throw new ArgumentNullException(nameof(formatArguments));
-                }
-
-                _messageFormat = messageFormat;
-                _formatArguments = new string[formatArguments.Length];
-                for (var i = 0; i < formatArguments.Length; i++)
-                {
-                    _formatArguments[i] = $"{formatArguments[i]}";
-                }
-            }
-
-            private LocalizableStringWithArguments(ObjectReader reader)
-            {
-                _messageFormat = (LocalizableString)reader.ReadValue();
-
-                var length = reader.ReadInt32();
-                if (length == 0)
-                {
-                    _formatArguments = Array.Empty<string>();
-                }
-                else
-                {
-                    using var argumentsBuilderDisposer = ArrayBuilder<string>.GetInstance(length, out var argumentsBuilder);
-                    for (var i = 0; i < length; i++)
-                    {
-                        argumentsBuilder.Add(reader.ReadString());
-                    }
-
-                    _formatArguments = argumentsBuilder.ToArray();
-                }
-            }
-
-            bool IObjectWritable.ShouldReuseInSerialization => false;
-
-            void IObjectWritable.WriteTo(ObjectWriter writer)
-            {
-                writer.WriteValue(_messageFormat);
-                var length = _formatArguments.Length;
-                writer.WriteInt32(length);
-                for (var i = 0; i < length; i++)
-                {
-                    writer.WriteString(_formatArguments[i]);
-                }
-            }
-
-            protected override string GetText(IFormatProvider? formatProvider)
-            {
-                var messageFormat = _messageFormat.ToString(formatProvider);
-                return messageFormat != null ?
-                    (_formatArguments.Length > 0 ? string.Format(formatProvider, messageFormat, _formatArguments) : messageFormat) :
-                    string.Empty;
-            }
-
-            protected override bool AreEqual(object? other)
-            {
-                return other is LocalizableStringWithArguments otherResourceString &&
-                    _messageFormat.Equals(otherResourceString._messageFormat) &&
-                    _formatArguments.SequenceEqual(otherResourceString._formatArguments, (a, b) => a == b);
-            }
-
-            protected override int GetHash()
-            {
-                return Hash.Combine(
-                    _messageFormat.GetHashCode(),
-                    Hash.CombineValues(_formatArguments));
-            }
-        }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/MakeFieldReadonly/MakeFieldReadonlyDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/MakeFieldReadonly/MakeFieldReadonlyDiagnosticAnalyzer.cs
index 59059cfe0fede..2c98a823bebc7 100644
--- a/src/Analyzers/Core/Analyzers/MakeFieldReadonly/MakeFieldReadonlyDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/MakeFieldReadonly/MakeFieldReadonlyDiagnosticAnalyzer.cs
@@ -101,13 +101,13 @@ void OnSymbolEnd(SymbolAnalysisContext symbolEndContext)
                             if (isCandidate && !written)
                             {
                                 var option = GetCodeStyleOption(field, symbolEndContext.Options);
-                                var diagnostic = DiagnosticHelper.Create(
+                                DiagnosticHelper.CreateAndReportDiagnostic(
+                                    symbolEndContext.ReportDiagnostic,
                                     Descriptor,
                                     field.Locations[0],
                                     option.Notification.Severity,
                                     additionalLocations: null,
                                     properties: null);
-                                symbolEndContext.ReportDiagnostic(diagnostic);
                             }
                         }
                     }
diff --git a/src/Analyzers/Core/Analyzers/NamingStyle/NamingStyleDiagnosticAnalyzerBase.cs b/src/Analyzers/Core/Analyzers/NamingStyle/NamingStyleDiagnosticAnalyzerBase.cs
index d0654f0214c51..e0b8e7b86c303 100644
--- a/src/Analyzers/Core/Analyzers/NamingStyle/NamingStyleDiagnosticAnalyzerBase.cs
+++ b/src/Analyzers/Core/Analyzers/NamingStyle/NamingStyleDiagnosticAnalyzerBase.cs
@@ -62,17 +62,13 @@ private void CompilationStartAction(CompilationStartAnalysisContext context)
 
             void SymbolAction(SymbolAnalysisContext symbolContext)
             {
-                var diagnostic = TryGetDiagnostic(
+                TryGetAndReportDiagnostic(
+                    symbolContext.ReportDiagnostic,
                     symbolContext.Compilation,
                     symbolContext.Symbol,
                     symbolContext.Options,
                     idToCachedResult,
                     symbolContext.CancellationToken);
-
-                if (diagnostic != null)
-                {
-                    symbolContext.ReportDiagnostic(diagnostic);
-                }
             }
 
             void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
@@ -84,24 +80,21 @@ void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
                     return;
                 }
 
-                var diagnostic = TryGetDiagnostic(
+                TryGetAndReportDiagnostic(
+                    syntaxContext.ReportDiagnostic,
                     syntaxContext.Compilation,
                     symbol,
                     syntaxContext.Options,
                     idToCachedResult,
                     syntaxContext.CancellationToken);
-
-                if (diagnostic != null)
-                {
-                    syntaxContext.ReportDiagnostic(diagnostic);
-                }
             }
         }
 
         private static readonly Func<Guid, ConcurrentDictionary<string, string?>> s_createCache =
             _ => new ConcurrentDictionary<string, string?>(concurrencyLevel: 2, capacity: 0);
 
-        private Diagnostic? TryGetDiagnostic(
+        private void TryGetAndReportDiagnostic(
+            Action<Diagnostic> reportDiagnostic,
             Compilation compilation,
             ISymbol symbol,
             AnalyzerOptions options,
@@ -110,28 +103,28 @@ void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
         {
             if (string.IsNullOrEmpty(symbol.Name))
             {
-                return null;
+                return;
             }
 
             if (symbol is IMethodSymbol methodSymbol && methodSymbol.IsEntryPoint(compilation.TaskType(), compilation.TaskOfTType()))
             {
-                return null;
+                return;
             }
 
             if (ShouldIgnore(symbol))
             {
-                return null;
+                return;
             }
 
             if (symbol.IsSymbolWithSpecialDiscardName())
             {
-                return null;
+                return;
             }
 
             var sourceTree = symbol.Locations.FirstOrDefault()?.SourceTree;
             if (sourceTree == null)
             {
-                return null;
+                return;
             }
 
             var namingPreferences = options.GetAnalyzerOptions(sourceTree).NamingPreferences;
@@ -140,7 +133,7 @@ void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
             if (!namingStyleRules.TryGetApplicableRule(symbol, out var applicableRule) ||
                 applicableRule.EnforcementLevel == ReportDiagnostic.Suppress)
             {
-                return null;
+                return;
             }
 
             var cache = idToCachedResult.GetOrAdd(applicableRule.NamingStyle.ID, s_createCache);
@@ -157,7 +150,7 @@ void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
 
             if (failureReason == null)
             {
-                return null;
+                return;
             }
 
             var builder = ImmutableDictionary.CreateBuilder<string, string?>();
@@ -165,7 +158,7 @@ void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
             builder["OptionName"] = nameof(NamingStyleOptions.NamingPreferences);
             builder["OptionLanguage"] = compilation.Language;
 
-            return DiagnosticHelper.Create(Descriptor, symbol.Locations.First(), applicableRule.EnforcementLevel, additionalLocations: null, builder.ToImmutable(), failureReason);
+            DiagnosticHelper.CreateAndReportDiagnostic(reportDiagnostic, Descriptor, symbol.Locations.First(), applicableRule.EnforcementLevel, additionalLocations: null, builder.ToImmutable(), failureReason);
         }
 
         public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
diff --git a/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs
index b1495b0f7d8bd..086d158234f31 100644
--- a/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/NewLines/ConsecutiveStatementPlacement/AbstractConsecutiveStatementPlacementDiagnosticAnalyzer.cs
@@ -103,12 +103,13 @@ private void ProcessBlockLikeStatement(SyntaxTreeAnalysisContext context, Report
                 return;
             }
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 this.Descriptor,
                 GetDiagnosticLocation(block),
                 severity,
                 additionalLocations: ImmutableArray.Create(nextToken.GetLocation()),
-                properties: null));
+                properties: null);
         }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/NewLines/MultipleBlankLines/AbstractMultipleBlankLinesDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/NewLines/MultipleBlankLines/AbstractMultipleBlankLinesDiagnosticAnalyzer.cs
index aa547ccba89ad..f98d9eed14c4f 100644
--- a/src/Analyzers/Core/Analyzers/NewLines/MultipleBlankLines/AbstractMultipleBlankLinesDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/NewLines/MultipleBlankLines/AbstractMultipleBlankLinesDiagnosticAnalyzer.cs
@@ -74,12 +74,13 @@ private void CheckToken(SyntaxTreeAnalysisContext context, ReportDiagnostic seve
             if (!ContainsMultipleBlankLines(token, out var badTrivia))
                 return;
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 this.Descriptor,
                 Location.Create(badTrivia.SyntaxTree!, new TextSpan(badTrivia.SpanStart, 0)),
                 severity,
                 additionalLocations: ImmutableArray.Create(token.GetLocation()),
-                properties: null));
+                properties: null);
         }
 
         private bool ContainsMultipleBlankLines(SyntaxToken token, out SyntaxTrivia firstBadTrivia)
diff --git a/src/Analyzers/Core/Analyzers/OrderModifiers/AbstractOrderModifiersDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/OrderModifiers/AbstractOrderModifiersDiagnosticAnalyzer.cs
index 5dcbe9d0a1746..53a7fe782bf95 100644
--- a/src/Analyzers/Core/Analyzers/OrderModifiers/AbstractOrderModifiersDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/OrderModifiers/AbstractOrderModifiersDiagnosticAnalyzer.cs
@@ -79,8 +79,7 @@ protected void CheckModifiers(
                 {
                     // If the Severity is not hidden, then just put the user visible portion on the
                     // first token.  That way we don't 
-                    context.ReportDiagnostic(
-                        DiagnosticHelper.Create(Descriptor, modifiers.First().GetLocation(), severity, additionalLocations: null, properties: null));
+                    DiagnosticHelper.CreateAndReportDiagnostic(context.ReportDiagnostic, Descriptor, modifiers.First().GetLocation(), severity, additionalLocations: null, properties: null);
                 }
             }
         }
diff --git a/src/Analyzers/Core/Analyzers/QualifyMemberAccess/AbstractQualifyMemberAccessDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/QualifyMemberAccess/AbstractQualifyMemberAccessDiagnosticAnalyzer.cs
index 8a4167e5ebce1..78c54496d9192 100644
--- a/src/Analyzers/Core/Analyzers/QualifyMemberAccess/AbstractQualifyMemberAccessDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/QualifyMemberAccess/AbstractQualifyMemberAccessDiagnosticAnalyzer.cs
@@ -134,12 +134,13 @@ private void AnalyzeOperation(OperationAnalysisContext context, IOperation opera
 
             if (!IsAlreadyQualifiedMemberAccess(simpleName))
             {
-                context.ReportDiagnostic(DiagnosticHelper.Create(
+                DiagnosticHelper.CreateAndReportDiagnostic(
+                    context.ReportDiagnostic,
                     Descriptor,
                     GetLocation(operation),
                     severity,
                     additionalLocations: null,
-                    properties: null));
+                    properties: null);
             }
         }
 
diff --git a/src/Analyzers/Core/Analyzers/RemoveUnnecessaryParentheses/AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/RemoveUnnecessaryParentheses/AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs
index 8f96217e96f7a..bb27db225ddc0 100644
--- a/src/Analyzers/Core/Analyzers/RemoveUnnecessaryParentheses/AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveUnnecessaryParentheses/AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer.cs
@@ -111,12 +111,13 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 parenthesizedExpression.GetFirstToken().GetLocation(),
                 parenthesizedExpression.GetLastToken().GetLocation());
 
-            context.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+            DiagnosticHelper.CreateWithLocationTagsAndReport(
+                context.ReportDiagnostic,
                 Descriptor,
                 AbstractRemoveUnnecessaryParenthesesDiagnosticAnalyzer<TLanguageKindEnum, TParenthesizedExpressionSyntax>.GetDiagnosticSquiggleLocation(parenthesizedExpression, cancellationToken),
                 severity,
                 additionalLocations,
-                additionalUnnecessaryLocations));
+                additionalUnnecessaryLocations);
         }
 
         /// <summary>
diff --git a/src/Analyzers/Core/Analyzers/RemoveUnusedMembers/AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/RemoveUnusedMembers/AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs
index 52fb5b1a6786e..ab7425a847eee 100644
--- a/src/Analyzers/Core/Analyzers/RemoveUnusedMembers/AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveUnusedMembers/AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs
@@ -41,8 +41,22 @@ internal abstract class AbstractRemoveUnusedMembersDiagnosticAnalyzer<TDocumenta
             new LocalizableResourceString(nameof(AnalyzersResources.Private_member_0_can_be_removed_as_the_value_assigned_to_it_is_never_read), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
             isUnnecessary: true);
 
+        internal static readonly DiagnosticDescriptor s_removeUnreadMembersRuleForProperties = CreateDescriptor(
+            IDEDiagnosticIds.RemoveUnreadMembersDiagnosticId,
+            EnforceOnBuildValues.RemoveUnreadMembers,
+            new LocalizableResourceString(nameof(AnalyzersResources.Remove_unread_private_members), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            new LocalizableResourceString(nameof(AnalyzersResources.Private_property_0_can_be_converted_to_a_method_as_its_get_accessor_is_never_invoked), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            isUnnecessary: true);
+
+        internal static readonly DiagnosticDescriptor s_removeUnreadMembersRuleForMethods = CreateDescriptor(
+            IDEDiagnosticIds.RemoveUnreadMembersDiagnosticId,
+            EnforceOnBuildValues.RemoveUnreadMembers,
+            new LocalizableResourceString(nameof(AnalyzersResources.Remove_unread_private_members), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            new LocalizableResourceString(nameof(AnalyzersResources.Private_method_0_can_be_removed_as_it_is_never_invoked), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            isUnnecessary: true);
+
         protected AbstractRemoveUnusedMembersDiagnosticAnalyzer()
-            : base(ImmutableArray.Create(s_removeUnusedMembersRule, s_removeUnreadMembersRule),
+            : base(ImmutableArray.Create(s_removeUnusedMembersRule, s_removeUnreadMembersRule, s_removeUnreadMembersRuleForProperties, s_removeUnreadMembersRuleForMethods),
                    GeneratedCodeAnalysisFlags.Analyze) // We want to analyze references in generated code, but not report unused members in generated code.
         {
         }
@@ -461,7 +475,7 @@ private void OnSymbolEnd(SymbolAnalysisContext symbolEndContext, bool hasUnsuppo
                             // Report IDE0051 or IDE0052 based on whether the underlying member has any Write/WritableRef/NonReadWriteRef references or not.
                             var rule = !valueUsageInfo.IsWrittenTo() && !valueUsageInfo.IsNameOnly() && !symbolsReferencedInDocComments.Contains(member)
                                 ? s_removeUnusedMembersRule
-                                : s_removeUnreadMembersRule;
+                                : GetUnreadMembersRule(member);
 
                             // Do not flag write-only properties that are not read.
                             // Write-only properties are assumed to have side effects
@@ -475,14 +489,14 @@ member is IPropertySymbol property &&
 
                             // Most of the members should have a single location, except for partial methods.
                             // We report the diagnostic on the first location of the member.
-                            var diagnostic = DiagnosticHelper.CreateWithMessage(
+                            DiagnosticHelper.CreateAndReportDiagnostic(
+                                symbolEndContext.ReportDiagnostic,
                                 rule,
                                 member.Locations[0],
                                 rule.GetEffectiveSeverity(symbolEndContext.Compilation.Options),
                                 additionalLocations: null,
                                 properties: null,
-                                GetMessage(rule, member));
-                            symbolEndContext.ReportDiagnostic(diagnostic);
+                                $"{member.ContainingType.Name}.{member.Name}");
                         }
                     }
                 }
@@ -495,35 +509,27 @@ member is IPropertySymbol property &&
                 return;
             }
 
-            private LocalizableString GetMessage(
-               DiagnosticDescriptor rule,
-               ISymbol member)
+            private DiagnosticDescriptor GetUnreadMembersRule(ISymbol member)
             {
-                var messageFormat = rule.MessageFormat;
-                if (rule == s_removeUnreadMembersRule)
+                // IDE0052 has a different message for method and property symbols.
+                switch (member)
                 {
-                    // IDE0052 has a different message for method and property symbols.
-                    switch (member)
-                    {
-                        case IMethodSymbol _:
-                            messageFormat = AnalyzersResources.Private_method_0_can_be_removed_as_it_is_never_invoked;
-                            break;
-
-                        case IPropertySymbol property:
-                            // We change the message only if both 'get' and 'set' accessors are present and
-                            // there are no shadow 'get' accessor usages. Otherwise the message will be confusing
-                            if (property.GetMethod != null && property.SetMethod != null &&
-                                !_propertiesWithShadowGetAccessorUsages.Contains(property))
-                            {
-                                messageFormat = AnalyzersResources.Private_property_0_can_be_converted_to_a_method_as_its_get_accessor_is_never_invoked;
-                            }
+                    case IMethodSymbol:
+                        return s_removeUnreadMembersRuleForMethods;
+
+                    case IPropertySymbol property:
+                        // We change the message only if both 'get' and 'set' accessors are present and
+                        // there are no shadow 'get' accessor usages. Otherwise the message will be confusing
+                        if (property.GetMethod != null && property.SetMethod != null &&
+                            !_propertiesWithShadowGetAccessorUsages.Contains(property))
+                        {
+                            return s_removeUnreadMembersRuleForProperties;
+                        }
 
-                            break;
-                    }
+                        break;
                 }
 
-                var memberName = $"{member.ContainingType.Name}.{member.Name}";
-                return new DiagnosticHelper.LocalizableStringWithArguments(messageFormat, memberName);
+                return s_removeUnreadMembersRule;
             }
 
             private static bool HasSyntaxErrors(INamedTypeSymbol namedTypeSymbol, CancellationToken cancellationToken)
diff --git a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs
index 54cd8810a9382..e15d577ca32f8 100644
--- a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs
@@ -248,12 +248,13 @@ private void AnalyzeExpressionStatement(OperationAnalysisContext context)
                     }
 
                     var properties = s_propertiesMap[(_options.UnusedValueExpressionStatementPreference, isUnusedLocalAssignment: false, isRemovableAssignment: false)];
-                    var diagnostic = DiagnosticHelper.Create(s_expressionValueIsUnusedRule,
-                                                             value.Syntax.GetLocation(),
-                                                             _options.UnusedValueExpressionStatementSeverity,
-                                                             additionalLocations: null,
-                                                             properties);
-                    context.ReportDiagnostic(diagnostic);
+                    DiagnosticHelper.CreateAndReportDiagnostic(
+                        context.ReportDiagnostic,
+                        s_expressionValueIsUnusedRule,
+                        value.Syntax.GetLocation(),
+                        _options.UnusedValueExpressionStatementSeverity,
+                        additionalLocations: null,
+                        properties);
                 }
 
                 private void AnalyzeDelegateCreationOrAnonymousFunction(OperationAnalysisContext operationAnalysisContext)
@@ -602,13 +603,14 @@ private void AnalyzeUnusedValueAssignments(
 
                             if (ShouldReportUnusedValueDiagnostic(symbol, unreadWriteOperation, symbolUsageResult, out var properties))
                             {
-                                var diagnostic = DiagnosticHelper.Create(s_valueAssignedIsUnusedRule,
-                                                                         _symbolStartAnalyzer._compilationAnalyzer.GetDefinitionLocationToFade(unreadWriteOperation),
-                                                                         _options.UnusedValueAssignmentSeverity,
-                                                                         additionalLocations: null,
-                                                                         properties,
-                                                                         symbol.Name);
-                                context.ReportDiagnostic(diagnostic);
+                                DiagnosticHelper.CreateAndReportDiagnostic(
+                                    context.ReportDiagnostic,
+                                    s_valueAssignedIsUnusedRule,
+                                    _symbolStartAnalyzer._compilationAnalyzer.GetDefinitionLocationToFade(unreadWriteOperation),
+                                    _options.UnusedValueAssignmentSeverity,
+                                    additionalLocations: null,
+                                    properties,
+                                    symbol.Name);
                             }
                         }
                     }
diff --git a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs
index 33def796ead0c..2fcd8e95090c4 100644
--- a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs
@@ -144,41 +144,35 @@ private void ReportUnusedParameterDiagnostic(
                     return;
                 }
 
-                var message = GetMessageForUnusedParameterDiagnostic(
-                    parameter.Name,
+                var rule = GetDescriptorForUnusedParameterDiagnostic(
                     hasReference,
                     isPublicApiParameter: parameter.ContainingSymbol.HasPublicResultantVisibility(),
                     isLocalFunctionParameter: parameter.ContainingSymbol.IsLocalFunction());
 
-                var diagnostic = DiagnosticHelper.CreateWithMessage(s_unusedParameterRule, location,
-                    option.Notification.Severity, additionalLocations: null, properties: null, message);
-                reportDiagnostic(diagnostic);
+                DiagnosticHelper.CreateAndReportDiagnostic(reportDiagnostic, rule, location,
+                    option.Notification.Severity, additionalLocations: null, properties: null, parameter.Name);
             }
 
-            private static LocalizableString GetMessageForUnusedParameterDiagnostic(
-                string parameterName,
+            private static DiagnosticDescriptor GetDescriptorForUnusedParameterDiagnostic(
                 bool hasReference,
                 bool isPublicApiParameter,
                 bool isLocalFunctionParameter)
             {
-                LocalizableString messageFormat;
                 if (isPublicApiParameter &&
                     !isLocalFunctionParameter)
                 {
-                    messageFormat = hasReference
-                        ? AnalyzersResources.Parameter_0_can_be_removed_if_it_is_not_part_of_a_shipped_public_API_its_initial_value_is_never_used
-                        : AnalyzersResources.Remove_unused_parameter_0_if_it_is_not_part_of_a_shipped_public_API;
+                    return hasReference
+                        ? s_unusedParameterRuleForPublicApiHasReference
+                        : s_unusedParameterRuleForPublicApiNoReference;
                 }
                 else if (hasReference)
                 {
-                    messageFormat = AnalyzersResources.Parameter_0_can_be_removed_its_initial_value_is_never_used;
+                    return s_unusedParameterRuleForNonPublicApiHasReference;
                 }
                 else
                 {
-                    messageFormat = s_unusedParameterRule.MessageFormat;
+                    return s_unusedParameterRule;
                 }
-
-                return new DiagnosticHelper.LocalizableStringWithArguments(messageFormat, parameterName);
             }
 
             private static IEnumerable<INamedTypeSymbol> GetAttributesForMethodsToIgnore(Compilation compilation)
diff --git a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
index 9e11f83d22ebc..39e5d6d6a043d 100644
--- a/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs
@@ -87,6 +87,30 @@ internal abstract partial class AbstractRemoveUnusedParametersAndValuesDiagnosti
             description: new LocalizableResourceString(nameof(AnalyzersResources.Avoid_unused_parameters_in_your_code_If_the_parameter_cannot_be_removed_then_change_its_name_so_it_starts_with_an_underscore_and_is_optionally_followed_by_an_integer_such_as__comma__1_comma__2_etc_These_are_treated_as_special_discard_symbol_names), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
             isUnnecessary: true);
 
+        private static readonly DiagnosticDescriptor s_unusedParameterRuleForPublicApiHasReference = CreateDescriptorWithId(
+            IDEDiagnosticIds.UnusedParameterDiagnosticId,
+            EnforceOnBuildValues.UnusedParameter,
+            new LocalizableResourceString(nameof(AnalyzersResources.Remove_unused_parameter), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            new LocalizableResourceString(nameof(AnalyzersResources.Parameter_0_can_be_removed_if_it_is_not_part_of_a_shipped_public_API_its_initial_value_is_never_used), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            description: new LocalizableResourceString(nameof(AnalyzersResources.Avoid_unused_parameters_in_your_code_If_the_parameter_cannot_be_removed_then_change_its_name_so_it_starts_with_an_underscore_and_is_optionally_followed_by_an_integer_such_as__comma__1_comma__2_etc_These_are_treated_as_special_discard_symbol_names), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            isUnnecessary: true);
+
+        private static readonly DiagnosticDescriptor s_unusedParameterRuleForPublicApiNoReference = CreateDescriptorWithId(
+            IDEDiagnosticIds.UnusedParameterDiagnosticId,
+            EnforceOnBuildValues.UnusedParameter,
+            new LocalizableResourceString(nameof(AnalyzersResources.Remove_unused_parameter), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            new LocalizableResourceString(nameof(AnalyzersResources.Remove_unused_parameter_0_if_it_is_not_part_of_a_shipped_public_API), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            description: new LocalizableResourceString(nameof(AnalyzersResources.Avoid_unused_parameters_in_your_code_If_the_parameter_cannot_be_removed_then_change_its_name_so_it_starts_with_an_underscore_and_is_optionally_followed_by_an_integer_such_as__comma__1_comma__2_etc_These_are_treated_as_special_discard_symbol_names), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            isUnnecessary: true);
+
+        private static readonly DiagnosticDescriptor s_unusedParameterRuleForNonPublicApiHasReference = CreateDescriptorWithId(
+            IDEDiagnosticIds.UnusedParameterDiagnosticId,
+            EnforceOnBuildValues.UnusedParameter,
+            new LocalizableResourceString(nameof(AnalyzersResources.Remove_unused_parameter), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            new LocalizableResourceString(nameof(AnalyzersResources.Parameter_0_can_be_removed_its_initial_value_is_never_used), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            description: new LocalizableResourceString(nameof(AnalyzersResources.Avoid_unused_parameters_in_your_code_If_the_parameter_cannot_be_removed_then_change_its_name_so_it_starts_with_an_underscore_and_is_optionally_followed_by_an_integer_such_as__comma__1_comma__2_etc_These_are_treated_as_special_discard_symbol_names), AnalyzersResources.ResourceManager, typeof(AnalyzersResources)),
+            isUnnecessary: true);
+
         private static readonly PropertiesMap s_propertiesMap = CreatePropertiesMap();
 
         protected AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer(
@@ -97,7 +121,10 @@ protected AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer(
                         .Add(s_expressionValueIsUnusedRule, unusedValueExpressionStatementOption)
                         .Add(s_valueAssignedIsUnusedRule, unusedValueAssignmentOption),
                    ImmutableDictionary<DiagnosticDescriptor, IPerLanguageOption>.Empty
-                        .Add(s_unusedParameterRule, CodeStyleOptions2.UnusedParameters),
+                        .Add(s_unusedParameterRule, CodeStyleOptions2.UnusedParameters)
+                         .Add(s_unusedParameterRuleForPublicApiHasReference, CodeStyleOptions2.UnusedParameters)
+                         .Add(s_unusedParameterRuleForPublicApiNoReference, CodeStyleOptions2.UnusedParameters)
+                         .Add(s_unusedParameterRuleForNonPublicApiHasReference, CodeStyleOptions2.UnusedParameters),
                    language)
         {
         }
diff --git a/src/Analyzers/Core/Analyzers/SimplifyBooleanExpression/AbstractSimplifyConditionalDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/SimplifyBooleanExpression/AbstractSimplifyConditionalDiagnosticAnalyzer.cs
index 59d2a0312030e..f3662de5a046e 100644
--- a/src/Analyzers/Core/Analyzers/SimplifyBooleanExpression/AbstractSimplifyConditionalDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/SimplifyBooleanExpression/AbstractSimplifyConditionalDiagnosticAnalyzer.cs
@@ -137,12 +137,13 @@ private void AnalyzeConditionalExpression(SyntaxNodeAnalysisContext context)
             // local functions
 
             void ReportDiagnostic(ImmutableDictionary<string, string?> properties)
-                => context.ReportDiagnostic(DiagnosticHelper.Create(
+                => DiagnosticHelper.CreateAndReportDiagnostic(
+                    context.ReportDiagnostic,
                     Descriptor,
                     conditionalExpression.GetLocation(),
                     styleOption.Notification.Severity,
                     additionalLocations: null,
-                    properties));
+                    properties);
 
             bool IsSimpleBooleanType(TExpressionSyntax node)
             {
diff --git a/src/Analyzers/Core/Analyzers/SimplifyInterpolation/AbstractSimplifyInterpolationDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/SimplifyInterpolation/AbstractSimplifyInterpolationDiagnosticAnalyzer.cs
index dad44fac24a4f..c00c53e76b99e 100644
--- a/src/Analyzers/Core/Analyzers/SimplifyInterpolation/AbstractSimplifyInterpolationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/SimplifyInterpolation/AbstractSimplifyInterpolationDiagnosticAnalyzer.cs
@@ -63,12 +63,13 @@ private void AnalyzeInterpolation(OperationAnalysisContext context)
             var firstUnnecessaryLocation = unnecessaryLocations[0];
             var remainingUnnecessaryLocations = unnecessaryLocations.RemoveAt(0);
 
-            context.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+            DiagnosticHelper.CreateWithLocationTagsAndReport(
+                context.ReportDiagnostic,
                 Descriptor,
                 firstUnnecessaryLocation,
                 option.Notification.Severity,
                 additionalLocations: ImmutableArray.Create(interpolation.Syntax.GetLocation()),
-                additionalUnnecessaryLocations: remainingUnnecessaryLocations));
+                additionalUnnecessaryLocations: remainingUnnecessaryLocations);
         }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/SimplifyLinqExpression/AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/SimplifyLinqExpression/AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs
index 90c50f6e40940..b86fd9ffa748e 100644
--- a/src/Analyzers/Core/Analyzers/SimplifyLinqExpression/AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/SimplifyLinqExpression/AbstractSimplifyLinqExpressionDiagnosticAnalyzer.cs
@@ -148,13 +148,13 @@ public void AnalyzeInvocationOperation(OperationAnalysisContext context, INamedT
                 return;
             }
 
-            context.ReportDiagnostic(
-                DiagnosticHelper.Create(
-                    Descriptor,
-                    nextInvocation.Syntax.GetLocation(),
-                    Descriptor.GetEffectiveSeverity(context.Compilation.Options),
-                    additionalLocations: null,
-                    properties: null));
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
+                Descriptor,
+                nextInvocation.Syntax.GetLocation(),
+                Descriptor.GetEffectiveSeverity(context.Compilation.Options),
+                additionalLocations: null,
+                properties: null);
 
             return;
 
diff --git a/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs
index 1f998e87d2fa1..50e1656542ec6 100644
--- a/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseAutoProperty/AbstractUseAutoPropertyAnalyzer.cs
@@ -331,7 +331,8 @@ private void Process(AnalysisResult result, SemanticModelAnalysisContext context
             }
 
             // Place the appropriate marker on the field depending on the user option.
-            var diagnostic1 = DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 fieldNode.GetLocation(),
                 option.Notification.Severity,
@@ -344,7 +345,6 @@ private void Process(AnalysisResult result, SemanticModelAnalysisContext context
                 Descriptor, propertyDeclaration.GetLocation(),
                 additionalLocations: additionalLocations);
 
-            context.ReportDiagnostic(diagnostic1);
             context.ReportDiagnostic(diagnostic2);
         }
 
diff --git a/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionDiagnosticAnalyzer.cs
index f7436057827f1..f621024331a3e 100644
--- a/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionDiagnosticAnalyzer.cs
@@ -125,12 +125,13 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 conditionPartToCheck.GetLocation(),
                 whenPartToCheck.GetLocation());
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 conditionalExpression.GetLocation(),
                 option.Notification.Severity,
                 locations,
-                properties: null));
+                properties: null);
         }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionForNullableDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionForNullableDiagnosticAnalyzer.cs
index b77d667770cf5..e6f0b6594175c 100644
--- a/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionForNullableDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseCoalesceExpression/AbstractUseCoalesceExpressionForNullableDiagnosticAnalyzer.cs
@@ -126,12 +126,13 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
                 conditionExpression.GetLocation(),
                 whenPartToKeep.GetLocation());
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 conditionalExpression.GetLocation(),
                 option.Notification.Severity,
                 locations,
-                properties: null));
+                properties: null);
         }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs
index 99964ef9a0d60..db7187baf4492 100644
--- a/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseCollectionInitializer/AbstractUseCollectionInitializerDiagnosticAnalyzer.cs
@@ -107,12 +107,13 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context, INamedTypeSymbol ien
 
             var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 objectCreationExpression.GetFirstToken().GetLocation(),
                 option.Notification.Severity,
                 additionalLocations: locations,
-                properties: null));
+                properties: null);
 
             FadeOutCode(context, matches.Value, locations);
         }
@@ -145,12 +146,13 @@ private void FadeOutCode(
                     // will be offered.
                     var location1 = additionalUnnecessaryLocations[0];
 
-                    context.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+                    DiagnosticHelper.CreateWithLocationTagsAndReport(
+                        context.ReportDiagnostic,
                         Descriptor,
                         location1,
                         ReportDiagnostic.Default,
                         additionalLocations: locations,
-                        additionalUnnecessaryLocations: additionalUnnecessaryLocations));
+                        additionalUnnecessaryLocations: additionalUnnecessaryLocations);
                 }
             }
         }
diff --git a/src/Analyzers/Core/Analyzers/UseCompoundAssignment/AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseCompoundAssignment/AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs
index 4b5759f979934..d461b22fe3982 100644
--- a/src/Analyzers/Core/Analyzers/UseCompoundAssignment/AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseCompoundAssignment/AbstractUseCompoundAssignmentDiagnosticAnalyzer.cs
@@ -144,34 +144,37 @@ private void AnalyzeAssignment(SyntaxNodeAnalysisContext context)
                 var incrementOrDecrement = TryGetIncrementOrDecrement(binaryKind, constant);
                 if (incrementOrDecrement == 1)
                 {
-                    context.ReportDiagnostic(DiagnosticHelper.Create(
+                    DiagnosticHelper.CreateAndReportDiagnostic(
+                        context.ReportDiagnostic,
                         _incrementDescriptor,
                         assignmentToken.GetLocation(),
                         option.Notification.Severity,
                         additionalLocations: ImmutableArray.Create(assignment.GetLocation()),
                         properties: ImmutableDictionary.Create<string, string?>()
-                            .Add(UseCompoundAssignmentUtilities.Increment, UseCompoundAssignmentUtilities.Increment)));
+                            .Add(UseCompoundAssignmentUtilities.Increment, UseCompoundAssignmentUtilities.Increment));
                     return;
                 }
                 else if (incrementOrDecrement == -1)
                 {
-                    context.ReportDiagnostic(DiagnosticHelper.Create(
+                    DiagnosticHelper.CreateAndReportDiagnostic(
+                        context.ReportDiagnostic,
                         _decrementDescriptor,
                         assignmentToken.GetLocation(),
                         option.Notification.Severity,
                         additionalLocations: ImmutableArray.Create(assignment.GetLocation()),
                         properties: ImmutableDictionary.Create<string, string?>()
-                            .Add(UseCompoundAssignmentUtilities.Decrement, UseCompoundAssignmentUtilities.Decrement)));
+                            .Add(UseCompoundAssignmentUtilities.Decrement, UseCompoundAssignmentUtilities.Decrement));
                     return;
                 }
             }
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 assignmentToken.GetLocation(),
                 option.Notification.Severity,
                 additionalLocations: ImmutableArray.Create(assignment.GetLocation()),
-                properties: null));
+                properties: null);
         }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/UseConditionalExpression/AbstractUseConditionalExpressionDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseConditionalExpression/AbstractUseConditionalExpressionDiagnosticAnalyzer.cs
index 521e324487d55..d23bd2ecb311f 100644
--- a/src/Analyzers/Core/Analyzers/UseConditionalExpression/AbstractUseConditionalExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseConditionalExpression/AbstractUseConditionalExpressionDiagnosticAnalyzer.cs
@@ -59,12 +59,13 @@ private void AnalyzeOperation(OperationAnalysisContext context)
             }
 
             var additionalLocations = ImmutableArray.Create(ifStatement.GetLocation());
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 ifStatement.GetFirstToken().GetLocation(),
                 option.Notification.Severity,
                 additionalLocations,
-                properties: null));
+                properties: null);
         }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/UseExplicitTupleName/UseExplicitTupleNameDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseExplicitTupleName/UseExplicitTupleNameDiagnosticAnalyzer.cs
index ca2efb155e6e8..dddf0588cfcfb 100644
--- a/src/Analyzers/Core/Analyzers/UseExplicitTupleName/UseExplicitTupleNameDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseExplicitTupleName/UseExplicitTupleNameDiagnosticAnalyzer.cs
@@ -61,12 +61,13 @@ private void AnalyzeOperation(OperationAnalysisContext context)
                         {
                             var properties = ImmutableDictionary<string, string?>.Empty.Add(
                                 nameof(ElementName), namedField.Name);
-                            context.ReportDiagnostic(DiagnosticHelper.Create(
+                            DiagnosticHelper.CreateAndReportDiagnostic(
+                                context.ReportDiagnostic,
                                 Descriptor,
                                 nameNode.GetLocation(),
                                 severity,
                                 additionalLocations: null,
-                                properties));
+                                properties);
                         }
                     }
                 }
diff --git a/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs
index a666c4596ea1b..2bba51fde1af3 100644
--- a/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseIsNullCheck/AbstractUseIsNullForReferenceEqualsDiagnosticAnalyzer.cs
@@ -138,11 +138,11 @@ private void AnalyzeSyntax(SyntaxNodeAnalysisContext context, IMethodSymbol refe
             }
 
             var severity = option.Notification.Severity;
-            context.ReportDiagnostic(
-                DiagnosticHelper.Create(
-                    Descriptor, nameNode.GetLocation(),
-                    severity,
-                    additionalLocations, properties));
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
+                Descriptor, nameNode.GetLocation(),
+                severity,
+                additionalLocations, properties);
         }
 
         private static ITypeParameterSymbol? GetGenericParameterSymbol(ISyntaxFacts syntaxFacts, SemanticModel semanticModel, SyntaxNode node1, SyntaxNode node2, CancellationToken cancellationToken)
diff --git a/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
index 611fb8b279530..e60667ffee7d8 100644
--- a/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseNullPropagation/AbstractUseNullPropagationDiagnosticAnalyzer.cs
@@ -178,12 +178,13 @@ private void AnalyzeSyntax(
                 properties = properties.Add(UseNullPropagationConstants.WhenPartIsNullable, "");
             }
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 conditionalExpression.GetLocation(),
                 option.Notification.Severity,
                 locations,
-                properties));
+                properties);
         }
 
         private bool TryAnalyzeCondition(
diff --git a/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs
index d7a659e87616c..25eb8fbed28cd 100644
--- a/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseObjectInitializer/AbstractUseObjectInitializerDiagnosticAnalyzer.cs
@@ -94,12 +94,13 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context)
 
             var locations = ImmutableArray.Create(objectCreationExpression.GetLocation());
 
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 objectCreationExpression.GetFirstToken().GetLocation(),
                 option.Notification.Severity,
                 locations,
-                properties: null));
+                properties: null);
 
             FadeOutCode(context, matches.Value, locations);
         }
@@ -128,13 +129,14 @@ private void FadeOutCode(
 
                 if (match.Statement.Span.End > match.Initializer.FullSpan.End)
                 {
-                    context.ReportDiagnostic(DiagnosticHelper.CreateWithLocationTags(
+                    DiagnosticHelper.CreateWithLocationTagsAndReport(
+                        context.ReportDiagnostic,
                         Descriptor,
                         location1,
                         ReportDiagnostic.Default,
                         additionalLocations: locations,
                         additionalUnnecessaryLocations: ImmutableArray.Create(
-                            syntaxTree.GetLocation(TextSpan.FromBounds(match.Initializer.FullSpan.End, match.Statement.Span.End)))));
+                            syntaxTree.GetLocation(TextSpan.FromBounds(match.Initializer.FullSpan.End, match.Statement.Span.End))));
                 }
                 else
                 {
diff --git a/src/Analyzers/Core/Analyzers/UseSystemHashCode/UseSystemHashCodeDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseSystemHashCode/UseSystemHashCodeDiagnosticAnalyzer.cs
index 906f807ee1c2a..6b8a934ccd98c 100644
--- a/src/Analyzers/Core/Analyzers/UseSystemHashCode/UseSystemHashCodeDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseSystemHashCode/UseSystemHashCodeDiagnosticAnalyzer.cs
@@ -71,12 +71,13 @@ private void AnalyzeOperationBlock(Analyzer analyzer, OperationBlockAnalysisCont
             var cancellationToken = context.CancellationToken;
             var operationLocation = operation.Syntax.GetLocation();
             var declarationLocation = context.OwningSymbol.DeclaringSyntaxReferences[0].GetSyntax(cancellationToken).GetLocation();
-            context.ReportDiagnostic(DiagnosticHelper.Create(
+            DiagnosticHelper.CreateAndReportDiagnostic(
+                context.ReportDiagnostic,
                 Descriptor,
                 owningSymbol.Locations[0],
                 option.Notification.Severity,
                 new[] { operationLocation, declarationLocation },
-                ImmutableDictionary<string, string?>.Empty));
+                ImmutableDictionary<string, string?>.Empty);
         }
     }
 }
diff --git a/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs b/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
index ac248ab899c67..8231d525d43f9 100644
--- a/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
+++ b/src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs
@@ -131,8 +131,7 @@ private void AnalyzeOperation(OperationAnalysisContext context, INamedTypeSymbol
                 throwOperation.Exception.Syntax.GetLocation(),
                 assignmentExpression.Value.Syntax.GetLocation());
 
-            context.ReportDiagnostic(
-                DiagnosticHelper.Create(Descriptor, throwStatementSyntax.GetLocation(), option.Notification.Severity, additionalLocations: allLocations, properties: null));
+            DiagnosticHelper.CreateAndReportDiagnostic(context.ReportDiagnostic, Descriptor, throwStatementSyntax.GetLocation(), option.Notification.Severity, additionalLocations: allLocations, properties: null);
         }
 
         private static bool ValueIsAccessed(SemanticModel semanticModel, IConditionalOperation ifOperation, IBlockOperation containingBlock, ISymbol localOrParameter, IExpressionStatementOperation expressionStatement, IAssignmentOperation assignmentExpression)
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionAnalyzer.cs b/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionAnalyzer.cs
index e8b43d92325da..01ed1855572f1 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionAnalyzer.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDetectionAnalyzer.cs
@@ -91,12 +91,13 @@ private void Analyze(
 
                         // Show this as a hidden diagnostic so the user can enable json features explicitly if they
                         // want, but do not spam them with a ... notification if they don't want it.
-                        context.ReportDiagnostic(DiagnosticHelper.Create(
+                        DiagnosticHelper.CreateAndReportDiagnostic(
+                            context.ReportDiagnostic,
                             this.Descriptor,
                             token.GetLocation(),
                             ReportDiagnostic.Hidden,
                             additionalLocations: null,
-                            properties));
+                            properties);
                     }
                 }
             }
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDiagnosticAnalyzer.cs b/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDiagnosticAnalyzer.cs
index ba5902fcdaa03..c1754a4881799 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDiagnosticAnalyzer.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/Json/LanguageServices/AbstractJsonDiagnosticAnalyzer.cs
@@ -77,13 +77,14 @@ private void Analyze(
                         {
                             foreach (var diag in tree.Diagnostics)
                             {
-                                context.ReportDiagnostic(DiagnosticHelper.Create(
+                                DiagnosticHelper.CreateAndReportDiagnostic(
+                                    context.ReportDiagnostic,
                                     this.Descriptor,
                                     Location.Create(context.SemanticModel.SyntaxTree, diag.Span),
                                     ReportDiagnostic.Warn,
                                     additionalLocations: null,
                                     properties: null,
-                                    diag.Message));
+                                    diag.Message);
                             }
                         }
                     }
diff --git a/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/AbstractRegexDiagnosticAnalyzer.cs b/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/AbstractRegexDiagnosticAnalyzer.cs
index 2e2a2deaf4fae..a70e7d9920ef4 100644
--- a/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/AbstractRegexDiagnosticAnalyzer.cs
+++ b/src/Features/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/AbstractRegexDiagnosticAnalyzer.cs
@@ -86,13 +86,14 @@ private void AnalyzeToken(
                 {
                     foreach (var diag in tree.Diagnostics)
                     {
-                        context.ReportDiagnostic(DiagnosticHelper.Create(
+                        DiagnosticHelper.CreateAndReportDiagnostic(
+                            context.ReportDiagnostic,
                             Descriptor,
                             Location.Create(context.SemanticModel.SyntaxTree, diag.Span),
                             ReportDiagnostic.Warn,
                             additionalLocations: null,
                             properties: null,
-                            diag.Message));
+                            diag.Message);
                     }
                 }
             }