Finish MEN018 code fixer

Author: menees

src/Menees.Analyzers.CodeFixes/Men018UseDigitSeparatorsFixer.cs

@@ -60,23 +60,37 @@ private static async Task<Document> GetTransformedDocumentAsync(
 		SyntaxNode? syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
 		if (syntaxRoot != null)
 		{
-			SyntaxNode violatingNode = syntaxRoot.FindNode(diagnostic.Location.SourceSpan);
-			if (violatingNode is LiteralExpressionSyntax literalExpression)
+			SyntaxNode oldNode = syntaxRoot.FindNode(diagnostic.Location.SourceSpan);
+			if (oldNode is LiteralExpressionSyntax literalExpression)
 			{
 				SyntaxToken literalToken = literalExpression.Token;
-
-				SyntaxNode oldNode = literalExpression;
-				SyntaxNode newNode = SyntaxFactory.LiteralExpression(
-					SyntaxKind.NumericLiteralExpression,
-					SyntaxFactory.Token(
-						literalToken.LeadingTrivia,
-						SyntaxKind.NumericLiteralToken,
-						preferredText,
-						preferredText,
-						literalToken.TrailingTrivia));
-
-				var newSyntaxRoot = syntaxRoot.ReplaceNode(oldNode, newNode);
-				result = document.WithSyntaxRoot(newSyntaxRoot);
+				SyntaxTriviaList lead = literalToken.LeadingTrivia;
+				SyntaxTriviaList trail = literalToken.TrailingTrivia;
+				SyntaxToken? newToken = Type.GetTypeCode(literalToken.Value?.GetType()) switch
+				{
+					TypeCode.SByte => SyntaxFactory.Literal(lead, preferredText, (sbyte)literalToken.Value!, trail),
+					TypeCode.Byte => SyntaxFactory.Literal(lead, preferredText, (byte)literalToken.Value!, trail),
+					TypeCode.Int16 => SyntaxFactory.Literal(lead, preferredText, (short)literalToken.Value!, trail),
+					TypeCode.UInt16 => SyntaxFactory.Literal(lead, preferredText, (ushort)literalToken.Value!, trail),
+					TypeCode.Int32 => SyntaxFactory.Literal(lead, preferredText, (int)literalToken.Value!, trail),
+					TypeCode.UInt32 => SyntaxFactory.Literal(lead, preferredText, (uint)literalToken.Value!, trail),
+					TypeCode.Int64 => SyntaxFactory.Literal(lead, preferredText, (long)literalToken.Value!, trail),
+					TypeCode.UInt64 => SyntaxFactory.Literal(lead, preferredText, (ulong)literalToken.Value!, trail),
+					TypeCode.Single => SyntaxFactory.Literal(lead, preferredText, (float)literalToken.Value!, trail),
+					TypeCode.Double => SyntaxFactory.Literal(lead, preferredText, (double)literalToken.Value!, trail),
+					TypeCode.Decimal => SyntaxFactory.Literal(lead, preferredText, (decimal)literalToken.Value!, trail),
+					_ => null,
+				};
+
+				if (newToken != null)
+				{
+					SyntaxNode newNode = SyntaxFactory.LiteralExpression(
+						SyntaxKind.NumericLiteralExpression,
+						newToken.Value);
+
+					var newSyntaxRoot = syntaxRoot.ReplaceNode(oldNode, newNode);
+					result = document.WithSyntaxRoot(newSyntaxRoot);
+				}
 			}
 		}
 

src/Menees.Analyzers/Men018UseDigitSeparators.cs

@@ -86,7 +86,7 @@ private static void HandleNumericLiteral(SyntaxNodeAnalysisContext context)
 					builder.Add(PreferredKey, preferredText);
 					ImmutableDictionary<string, string?> fixerProperties = builder.ToImmutable();
 
-					Location location = literalExpression.GetFirstLineLocation();
+					Location location = literalExpression.GetLocation();
 					context.ReportDiagnostic(Diagnostic.Create(Rule, location, fixerProperties, literalText));
 				}
 			}

src/Menees.Analyzers/NumericLiteral.cs

@@ -24,7 +24,7 @@ public sealed class NumericLiteral
 	private static readonly HashSet<char> HexadecimalDigits = [.. DecimalDigits, 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f'];
 	private static readonly char[] ExponentChar = ['e', 'E'];
 
-	private string originalText;
+	private readonly string originalText;
 
 	#endregion
 

tests/Menees.Analyzers.Test/Men018UnitTests.cs

@@ -1,12 +1,16 @@
 namespace Menees.Analyzers.Test;
 
+using Microsoft.CodeAnalysis.CodeFixes;
+
 [TestClass]
 public class Men018UnitTests : CodeFixVerifier
 {
 	#region Protected Properties
 
 	protected override DiagnosticAnalyzer CSharpDiagnosticAnalyzer => new Men018UseDigitSeparators();
 
+	protected override CodeFixProvider? CSharpCodeFixProvider => new Men018UseDigitSeparatorsFixer();
+
 	#endregion
 
 	#region ValidCodeTest
@@ -52,7 +56,7 @@ public class Test
 	private const int Thousand = 1000;
 	private const uint HexHundred = 0x100u;
 	private const ulong BinaryMillion = 0b1000000UL;
-	private const double BigDouble = 123456.789;
+	private const double BigDouble = 123456.7890;
 }";
 
 		var analyzer = this.CSharpDiagnosticAnalyzer;
@@ -90,14 +94,53 @@ public class Test
 			},
 			new DiagnosticResult(analyzer)
 			{
-				Message = "The numeric literal 123456.789 should use digit separators.",
+				Message = "The numeric literal 123456.7890 should use digit separators.",
 				Locations = [new DiagnosticResultLocation("Test0.cs", 10, 35)]
 			},
 		];
 
-		// TODO: Add code fixer unit tests. [Bill, 5/26/2024]
 		this.VerifyCSharpDiagnostic(test, expected);
 	}
 
+	[TestMethod]
+	public void InvalidCodeFixerTest()
+	{
+		const string before = @"
+public class Test
+{
+	private const int Million = 1000000;
+	private const uint MaxUint = 0xFFFFFFFFu;
+	private const decimal TenBillion = 10000000000m;
+	private const int Thousand = 1000;
+	private const uint HexHundred = 0x100u;
+	private const ulong BinaryMillion = 0b1000000UL;
+	private const double BigDouble = 123456.7890;
+	private static readonly double Conditional = Convert.ToBoolean(0) ? 0xFFFFFF : 1234.56789;
+	public Test()
+	{
+		if (DateTime.Now.TimeOfDay.TotalSeconds >= 43200) Console.WriteLine(""Afternoon"");
+	}
+}";
+
+		const string after = @"
+public class Test
+{
+	private const int Million = 1_000_000;
+	private const uint MaxUint = 0x_FF_FF_FF_FFu;
+	private const decimal TenBillion = 10_000_000_000m;
+	private const int Thousand = 1_000;
+	private const uint HexHundred = 0x1_00u;
+	private const ulong BinaryMillion = 0b100_0000UL;
+	private const double BigDouble = 123_456.789_0;
+	private static readonly double Conditional = Convert.ToBoolean(0) ? 0x_FF_FF_FF : 1_234.567_89;
+	public Test()
+	{
+		if (DateTime.Now.TimeOfDay.TotalSeconds >= 43_200) Console.WriteLine(""Afternoon"");
+	}
+}";
+
+		this.VerifyCSharpFix(before, after);
+	}
+
 	#endregion
 }

tests/Menees.Analyzers.Test/Verifiers/CodeFixVerifier.cs

@@ -42,8 +42,13 @@ protected void VerifyCSharpFix(string oldSource, string newSource, int? codeFixI
 	/// <param name="allowNewCompilerDiagnostics">A bool controlling whether or not the test will fail if the CodeFix introduces other warnings after being applied</param>
 	private static void VerifyFix(string language, DiagnosticAnalyzer analyzer, CodeFixProvider? codeFixProvider, string oldSource, string newSource, int? codeFixIndex, bool allowNewCompilerDiagnostics)
 	{
-		if (IsEnabled(analyzer) && codeFixProvider != null)
+		if (IsEnabled(analyzer))
 		{
+			if (codeFixProvider is null)
+			{
+				throw new ArgumentNullException(nameof(codeFixProvider), $"{nameof(VerifyFix)} requires a code fix provider.");
+			}
+
 			var document = CreateDocument(oldSource, language);
 			var analyzerDiagnostics = GetSortedDiagnosticsFromDocuments(analyzer, [document]);
 			var compilerDiagnostics = GetCompilerDiagnostics(document);
@@ -83,10 +88,10 @@ private static void VerifyFix(string language, DiagnosticAnalyzer analyzer, Code
 
 					newCompilerDiagnostics = GetNewDiagnostics(compilerDiagnostics, GetCompilerDiagnostics(document));
 
-					Assert.IsTrue(false,
+					Assert.Fail(
 						string.Format("Fix introduced new compiler diagnostics:\r\n{0}\r\n\r\nNew document:\r\n{1}\r\n",
 							string.Join("\r\n", newCompilerDiagnostics.Select(d => d.ToString())),
-							document.GetSyntaxRootAsync().Result.ToFullString()));
+							document.GetSyntaxRootAsync().Result?.ToFullString()));
 				}
 
 				//check if there are analyzer diagnostics left after the code fix