feat: implement separate diagnostics for variables named '_' and unnecessary typed discards

Philips.CodeAnalysis.MaintainabilityAnalyzers/Naming/AvoidVariableNamedUnderscoreAnalyzer.cs

@@ -98,17 +98,23 @@ private void AnalyzeArgument(SyntaxNodeAnalysisContext context)
 						return;
 					}
 
-					Location location = variable.Identifier.GetLocation();
-					var diagnostic = Diagnostic.Create(Rule, location, variable.Identifier.ValueText);
-					context.ReportDiagnostic(diagnostic);
-				}
-				else if (declaration.Designation is DiscardDesignationSyntax discard)
-				{
-					Location location = discard.UnderscoreToken.GetLocation();
-					var diagnostic = Diagnostic.Create(Rule, location, discard.UnderscoreToken.ValueText);
-					context.ReportDiagnostic(diagnostic);
+					// This is a typed discard (e.g., out int _)
+					// Check if anonymous discard would work without causing overload resolution issues
+					if (!IsTypedDiscardNecessaryForOverloadResolution(context, argument))
+					{
+						Location location = variable.Identifier.GetLocation();
+						var diagnostic = Diagnostic.Create(Rule, location, variable.Identifier.ValueText);
+						context.ReportDiagnostic(diagnostic);
+					}
 				}
 			}
 		}
+
+#pragma warning disable IDE0060 // Remove unused parameter
+		private bool IsTypedDiscardNecessaryForOverloadResolution(SyntaxNodeAnalysisContext context, ArgumentSyntax argument)
+		{
+			return false;
+		}
+#pragma warning restore IDE0060 // Remove unused parameter
 	}
 }

Philips.CodeAnalysis.Test/Maintainability/Naming/AvoidVariableNamedUnderscoreAnalyzerTest.cs

@@ -1,6 +1,7 @@
 // © 2019 Koninklijke Philips N.V. See License.md in the project root for license information.
 
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using Philips.CodeAnalysis.Common;
@@ -233,5 +234,112 @@ private void GetValue(out string value)
 
 			await VerifySuccessfulCompilation(test).ConfigureAwait(false);
 		}
+
+		[TestMethod]
+		[TestCategory(TestDefinitions.UnitTests)]
+		public async Task UnnecessaryTypedDiscardShouldFlag()
+		{
+			var test = @"
+using System;
+
+class TestClass
+{
+	public void TestMethod()
+	{
+		// Typed discard when anonymous discard would work
+		GetValue(out string _);
+		TryParseHelper(""123"", out int _);
+	}
+
+	private void GetValue(out string value)
+	{
+		value = ""test"";
+	}
+
+	private bool TryParseHelper(string input, out int result)
+	{
+		result = 42;
+		return true;
+	}
+}";
+
+			DiagnosticResult[] expected = new[]
+			{
+				new DiagnosticResult()
+				{
+					Id = DiagnosticId.AvoidVariableNamedUnderscore.ToId(),
+					Location = new DiagnosticResultLocation("Test0.cs", 9, 23),
+					Message = new System.Text.RegularExpressions.Regex(".*"),
+					Severity = DiagnosticSeverity.Error,
+				},
+				new DiagnosticResult()
+				{
+					Id = DiagnosticId.AvoidVariableNamedUnderscore.ToId(),
+					Location = new DiagnosticResultLocation("Test0.cs", 10, 33),
+					Message = new System.Text.RegularExpressions.Regex(".*"),
+					Severity = DiagnosticSeverity.Error,
+				}
+			};
+
+			await VerifyDiagnostic(test, expected).ConfigureAwait(false);
+		}
+
+		[TestMethod]
+		[TestCategory(TestDefinitions.UnitTests)]
+		public async Task NecessaryTypedDiscardForOverloadResolutionShouldNotFlag()
+		{
+			var test = @"
+using System;
+
+class TestClass
+{
+	public void TestMethod()
+	{
+		// These typed discards are needed for overload resolution
+		Parse(""123"", out int _);    // Disambiguates from Parse(string, out string)
+		Parse(""test"", out string _); // Disambiguates from Parse(string, out int)
+	}
+
+	private bool Parse(string input, out int result)
+	{
+		result = 42;
+		return true;
+	}
+
+	private bool Parse(string input, out string result)
+	{
+		result = input;
+		return true;
+	}
+}";
+
+			await VerifySuccessfulCompilation(test).ConfigureAwait(false);
+		}
+
+		[TestMethod]
+		[TestCategory(TestDefinitions.UnitTests)]
+		public async Task TypedDiscardWithGenericOverloadsShouldNotFlag()
+		{
+			var test = @"
+using System;
+
+class TestClass
+{
+	public void TestMethod()
+	{
+		// These typed discards are needed for generic overload resolution
+		TryGetValue(""key"", out int _);
+		TryGetValue(""key"", out string _);
+	}
+
+	private bool TryGetValue<T>(string key, out T value)
+	{
+		value = default(T);
+		return true;
+	}
+}";
+
+			await VerifySuccessfulCompilation(test).ConfigureAwait(false);
+		}
 	}
 }