Don't trigger naming style violation for prefixed numbers.

src/Analyzers/CSharp/Tests/NamingStyles/NamingStylesTests.cs

@@ -1334,5 +1334,36 @@ await TestInRegularAndScriptAsync(
 @"public record Foo(int [|MyInt|]);",
                 options: s_options.MergeStyles(s_options.PropertyNamesArePascalCase, s_options.ParameterNamesAreCamelCaseWithPUnderscorePrefix));
         }
+
+        [Theory]
+        [InlineData("_")]
+        [InlineData("_1")]
+        [InlineData("_123")]
+        public async Task TestDiscardParameterAsync(string identifier)
+        {
+            await TestMissingInRegularAndScriptAsync(
+$@"class C
+{{
+    void M(int [|{identifier}|])
+    {{
+    }}
+}}", new TestParameters(options: s_options.ParameterNamesAreCamelCase));
+        }
+
+        [Theory]
+        [InlineData("_")]
+        [InlineData("_1")]
+        [InlineData("_123")]
+        public async Task TestDiscardLocalAsync(string identifier)
+        {
+            await TestMissingInRegularAndScriptAsync(
+$@"class C
+{{
+    void M()
+    {{
+        int [|{identifier}|] = 0;
+    }}
+}}", new TestParameters(options: s_options.LocalNamesAreCamelCase));
+        }
     }
 }

src/Analyzers/Core/Analyzers/NamingStyle/NamingStyleDiagnosticAnalyzerBase.cs

@@ -9,6 +9,7 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.NamingStyles;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
 using Roslyn.Utilities;
 
@@ -116,6 +117,11 @@ void SyntaxNodeAction(SyntaxNodeAnalysisContext syntaxContext)
                 return null;
             }
 
+            if (symbol.IsSymbolWithSpecialDiscardName())
+            {
+                return null;
+            }
+
             var namingPreferences = GetNamingStylePreferences(compilation, symbol, options, cancellationToken);
             if (namingPreferences == null)
             {

src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.BlockAnalyzer.cs

@@ -622,7 +622,7 @@ bool ShouldReportUnusedValueDiagnostic(
                         if (_options.UnusedValueAssignmentSeverity == ReportDiagnostic.Suppress ||
                             symbol.GetSymbolType().IsErrorType() ||
                             (symbol.IsStatic && symbol.Kind == SymbolKind.Local) ||
-                            IsSymbolWithSpecialDiscardName(symbol))
+                            symbol.IsSymbolWithSpecialDiscardName())
                         {
                             return false;
                         }

src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.SymbolStartAnalyzer.cs

@@ -259,7 +259,7 @@ private bool IsUnusedParameterCandidate(IParameterSymbol parameter)
                 // without disabling the diagnostic completely.
                 // We ignore parameter names that start with an underscore and are optionally followed by an integer,
                 // such as '_', '_1', '_2', etc.
-                if (IsSymbolWithSpecialDiscardName(parameter))
+                if (parameter.IsSymbolWithSpecialDiscardName())
                 {
                     return false;
                 }

src/Analyzers/Core/Analyzers/RemoveUnusedParametersAndValues/AbstractRemoveUnusedParametersAndValuesDiagnosticAnalyzer.cs

@@ -323,14 +323,5 @@ public static bool GetIsRemovableAssignmentDiagnostic(Diagnostic diagnostic)
             Debug.Assert(TryGetUnusedValuePreference(diagnostic, out _));
             return diagnostic.Properties.ContainsKey(IsRemovableAssignmentKey);
         }
-
-        /// <summary>
-        /// Returns true for symbols whose name starts with an underscore and
-        /// are optionally followed by an integer, such as '_', '_1', '_2', etc.
-        /// These are treated as special discard symbol names.
-        /// </summary>
-        private static bool IsSymbolWithSpecialDiscardName(ISymbol symbol)
-            => symbol.Name.StartsWith("_") &&
-               (symbol.Name.Length == 1 || uint.TryParse(symbol.Name.Substring(1), out _));
     }
 }

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ISymbolExtensions.cs

@@ -740,5 +740,14 @@ public static bool IsKind<TSymbol>(this ISymbol symbol, SymbolKind kind, [NotNul
             result = (TSymbol)symbol;
             return true;
         }
+
+        /// <summary>
+        /// Returns true for symbols whose name starts with an underscore and
+        /// are optionally followed by an integer, such as '_', '_1', '_2', etc.
+        /// These are treated as special discard symbol names.
+        /// </summary>
+        public static bool IsSymbolWithSpecialDiscardName(this ISymbol symbol)
+            => symbol.Name.StartsWith("_") &&
+               (symbol.Name.Length == 1 || uint.TryParse(symbol.Name.Substring(1), out _));
     }
 }