Breaking: Reorganized diagnostic IDs by category (XPC1xxx=Info, XPC2xxx=Plugin structure, XPC3xxx=Style, XPC4xxx=Handler methods, XPC5xxx=Internal errors)

Author: mkholt

XrmPluginCore.SourceGenerator.Tests/DiagnosticTests/DiagnosticReportingTests.cs

@@ -24,16 +24,16 @@ public void Should_Not_Report_XPC1000_Success_Diagnostic_On_Successful_Generatio
         var result = GeneratorTestHelper.RunGenerator(
             CompilationHelper.CreateCompilation(source));
 
-        // Assert - XPC1000 is no longer reported to avoid spamming the user
+        // Assert - XPC1001 is no longer reported to avoid spamming the user
         var successDiagnostics = result.GeneratorDiagnostics
-            .Where(d => d.Id == "XPC1000")
+            .Where(d => d.Id == "XPC1001")
             .ToArray();
 
-        successDiagnostics.Should().BeEmpty("XPC1000 success diagnostic should not be reported to avoid spam");
+        successDiagnostics.Should().BeEmpty("XPC1001 success diagnostic should not be reported to avoid spam");
     }
 
     [Fact]
-    public async Task Should_Report_XPC4001_When_Plugin_Has_No_Parameterless_Constructor()
+    public async Task Should_Report_XPC2001_When_Plugin_Has_No_Parameterless_Constructor()
     {
 		// Arrange - plugin class with only a parameterized constructor (no parameterless)
 		const string pluginSource = """
@@ -72,12 +72,12 @@ public class TestService : ITestService { public void Process(PreImage preImage)
         // Act - Run analyzer instead of generator
         var diagnostics = await GetAnalyzerDiagnosticsAsync(source, new NoParameterlessConstructorAnalyzer());
 
-        // Assert - should report XPC4001
+        // Assert - should report XPC2001
         var errorDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4001")
+            .Where(d => d.Id == "XPC2001")
             .ToArray();
 
-        errorDiagnostics.Should().NotBeEmpty("XPC4001 should be reported when plugin class has no parameterless constructor");
+        errorDiagnostics.Should().NotBeEmpty("XPC2001 should be reported when plugin class has no parameterless constructor");
         errorDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
     }
 
@@ -107,7 +107,7 @@ public void Should_Handle_XPC5000_Generation_Error_Gracefully()
     }
 
     [Fact]
-    public async Task Should_Report_XPC4002_When_Handler_Method_Not_Found()
+    public async Task Should_Report_XPC4001_When_Handler_Method_Not_Found()
     {
 		// Arrange - method reference points to NonExistentMethod but service has Process
 		const string pluginSource = """
@@ -153,15 +153,15 @@ public void Process() { }
 
         // Assert
         var errorDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4002")
+            .Where(d => d.Id == "XPC4001")
             .ToArray();
 
-        errorDiagnostics.Should().NotBeEmpty("XPC4002 should be reported when handler method is not found");
+        errorDiagnostics.Should().NotBeEmpty("XPC4001 should be reported when handler method is not found");
         errorDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Error);
     }
 
     [Fact]
-    public async Task Should_Report_XPC4003_When_Handler_Missing_PreImage_Parameter()
+    public async Task Should_Report_XPC4002_When_Handler_Missing_PreImage_Parameter()
     {
 		// Arrange - WithPreImage is registered but handler takes no parameters
 		const string pluginSource = """
@@ -207,16 +207,16 @@ public void Process() { }
 
         // Assert
         var errorDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4003")
+            .Where(d => d.Id == "XPC4002")
             .ToArray();
 
-        errorDiagnostics.Should().NotBeEmpty("XPC4003 should be reported when handler is missing PreImage parameter");
-        // XPC4003 is Warning when generated types don't exist yet (allows initial build to succeed)
+        errorDiagnostics.Should().NotBeEmpty("XPC4002 should be reported when handler is missing PreImage parameter");
+        // XPC4002 is Warning when generated types don't exist yet (allows initial build to succeed)
         errorDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
     }
 
     [Fact]
-    public async Task Should_Report_XPC4003_When_Handler_Missing_PostImage_Parameter()
+    public async Task Should_Report_XPC4002_When_Handler_Missing_PostImage_Parameter()
     {
 		// Arrange - WithPostImage is registered but handler takes no parameters
 		const string pluginSource = """
@@ -262,16 +262,16 @@ public void Process() { }
 
         // Assert
         var errorDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4003")
+            .Where(d => d.Id == "XPC4002")
             .ToArray();
 
-        errorDiagnostics.Should().NotBeEmpty("XPC4003 should be reported when handler is missing PostImage parameter");
-        // XPC4003 is Warning when generated types don't exist yet (allows initial build to succeed)
+        errorDiagnostics.Should().NotBeEmpty("XPC4002 should be reported when handler is missing PostImage parameter");
+        // XPC4002 is Warning when generated types don't exist yet (allows initial build to succeed)
         errorDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
     }
 
     [Fact]
-    public async Task Should_Report_XPC4003_When_Handler_Missing_Both_Image_Parameters()
+    public async Task Should_Report_XPC4002_When_Handler_Missing_Both_Image_Parameters()
     {
 		// Arrange - Both WithPreImage and WithPostImage but handler takes no parameters
 		const string pluginSource = """
@@ -318,16 +318,16 @@ public void Process() { }
 
         // Assert
         var errorDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4003")
+            .Where(d => d.Id == "XPC4002")
             .ToArray();
 
-        errorDiagnostics.Should().NotBeEmpty("XPC4003 should be reported when handler is missing both image parameters");
-        // XPC4003 is Warning when generated types don't exist yet (allows initial build to succeed)
+        errorDiagnostics.Should().NotBeEmpty("XPC4002 should be reported when handler is missing both image parameters");
+        // XPC4002 is Warning when generated types don't exist yet (allows initial build to succeed)
         errorDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
     }
 
     [Fact]
-    public async Task Should_Report_XPC4003_When_Handler_Has_Wrong_Parameter_Order()
+    public async Task Should_Report_XPC4002_When_Handler_Has_Wrong_Parameter_Order()
     {
 		// Arrange - WithPreImage and WithPostImage but handler has parameters in wrong order
 		const string pluginSource = """
@@ -375,16 +375,16 @@ public void Process(PostImage post, PreImage pre) { }
 
         // Assert
         var errorDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4003")
+            .Where(d => d.Id == "XPC4002")
             .ToArray();
 
-        errorDiagnostics.Should().NotBeEmpty("XPC4003 should be reported when handler has wrong parameter order");
-        // XPC4003 is Warning when generated types don't exist yet (allows initial build to succeed)
+        errorDiagnostics.Should().NotBeEmpty("XPC4002 should be reported when handler has wrong parameter order");
+        // XPC4002 is Warning when generated types don't exist yet (allows initial build to succeed)
         errorDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
     }
 
     [Fact]
-    public async Task Should_Report_XPC4004_When_WithPreImage_Used_With_Invocation_Syntax()
+    public async Task Should_Report_XPC3003_When_WithPreImage_Used_With_Invocation_Syntax()
     {
 		// Arrange - WithPreImage used with s => s.DoSomething() (invocation) instead of s => s.DoSomething (method reference)
 		const string pluginSource = """
@@ -430,15 +430,15 @@ public void DoSomething() { }
 
         // Assert
         var warningDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4004")
+            .Where(d => d.Id == "XPC3003")
             .ToArray();
 
-        warningDiagnostics.Should().NotBeEmpty("XPC4004 should be reported when WithPreImage is used with invocation syntax");
+        warningDiagnostics.Should().NotBeEmpty("XPC3003 should be reported when WithPreImage is used with invocation syntax");
         warningDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
     }
 
     [Fact]
-    public async Task Should_Report_XPC4004_When_WithPostImage_Used_With_Invocation_Syntax()
+    public async Task Should_Report_XPC3003_When_WithPostImage_Used_With_Invocation_Syntax()
     {
 		// Arrange - WithPostImage used with s => s.DoSomething() (invocation) instead of s => s.DoSomething (method reference)
 		const string pluginSource = """
@@ -484,15 +484,15 @@ public void DoSomething() { }
 
         // Assert
         var warningDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4004")
+            .Where(d => d.Id == "XPC3003")
             .ToArray();
 
-        warningDiagnostics.Should().NotBeEmpty("XPC4004 should be reported when WithPostImage is used with invocation syntax");
+        warningDiagnostics.Should().NotBeEmpty("XPC3003 should be reported when WithPostImage is used with invocation syntax");
         warningDiagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Warning);
     }
 
     [Fact]
-    public async Task Should_Not_Report_XPC4004_When_Using_Method_Reference_Syntax()
+    public async Task Should_Not_Report_XPC3003_When_Using_Method_Reference_Syntax()
     {
 		// Arrange - Method reference syntax (correct usage)
 		const string pluginSource = """
@@ -539,14 +539,14 @@ public void HandleUpdate(PreImage preImage) { }
 
         // Assert
         var warningDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4004")
+            .Where(d => d.Id == "XPC3003")
             .ToArray();
 
-        warningDiagnostics.Should().BeEmpty("XPC4004 should NOT be reported when using method reference syntax");
+        warningDiagnostics.Should().BeEmpty("XPC3003 should NOT be reported when using method reference syntax");
     }
 
     [Fact]
-    public async Task Should_Not_Report_XPC4004_When_Old_Api_Used_Without_Images()
+    public async Task Should_Not_Report_XPC3003_When_Old_Api_Used_Without_Images()
     {
 		// Arrange - Invocation syntax but without WithPreImage/WithPostImage (no images registered)
 		const string pluginSource = """
@@ -592,14 +592,14 @@ public void DoSomething() { }
 
         // Assert
         var warningDiagnostics = diagnostics
-            .Where(d => d.Id == "XPC4004")
+            .Where(d => d.Id == "XPC3003")
             .ToArray();
 
-        warningDiagnostics.Should().BeEmpty("XPC4004 should NOT be reported when old API is used without images");
+        warningDiagnostics.Should().BeEmpty("XPC3003 should NOT be reported when old API is used without images");
     }
 
     [Fact]
-    public async Task Should_Report_XPC4005_When_AddImage_Used_With_Invocation_Syntax()
+    public async Task Should_Report_XPC3002_When_AddImage_Used_With_Invocation_Syntax()
     {
 		// Arrange - AddImage (legacy API) used with s => s.DoSomething() (invocation)
 		const string pluginSource = """
@@ -643,24 +643,24 @@ public void DoSomething() { }
         // Act - Run analyzer instead of generator
         var diagnostics = await GetAnalyzerDiagnosticsAsync(source, new ImageWithoutMethodReferenceAnalyzer());
 
-        // Assert - Should report XPC4005 (Info) NOT XPC4004 (Warning)
-        var xpc4005Diagnostics = diagnostics
-            .Where(d => d.Id == "XPC4005")
+        // Assert - Should report XPC3002 (Info) NOT XPC3003 (Warning)
+        var xpc3002Diagnostics = diagnostics
+            .Where(d => d.Id == "XPC3002")
             .ToArray();
 
-        var xpc4004Diagnostics = diagnostics
-            .Where(d => d.Id == "XPC4004")
+        var xpc3003Diagnostics = diagnostics
+            .Where(d => d.Id == "XPC3003")
             .ToArray();
 
-        xpc4005Diagnostics.Should().NotBeEmpty("XPC4005 should be reported when AddImage is used with invocation syntax");
-        xpc4005Diagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Info);
-        xpc4004Diagnostics.Should().BeEmpty("XPC4004 should NOT be reported for legacy AddImage API");
+        xpc3002Diagnostics.Should().NotBeEmpty("XPC3002 should be reported when AddImage is used with invocation syntax");
+        xpc3002Diagnostics.Should().OnlyContain(d => d.Severity == DiagnosticSeverity.Info);
+        xpc3003Diagnostics.Should().BeEmpty("XPC3003 should NOT be reported for legacy AddImage API");
     }
 
     [Fact]
-    public async Task Should_Report_XPC4004_Not_XPC4005_When_WithPreImage_Used_Even_With_AddImage()
+    public async Task Should_Report_XPC3003_Not_XPC3002_When_WithPreImage_Used_Even_With_AddImage()
     {
-		// Arrange - Both WithPreImage (modern) and AddImage (legacy) used - should report XPC4004 since modern takes precedence
+		// Arrange - Both WithPreImage (modern) and AddImage (legacy) used - should report XPC3003 since modern takes precedence
 		const string pluginSource = """
 
 			using XrmPluginCore;
@@ -703,17 +703,17 @@ public void DoSomething() { }
         // Act - Run analyzer instead of generator
         var diagnostics = await GetAnalyzerDiagnosticsAsync(source, new ImageWithoutMethodReferenceAnalyzer());
 
-        // Assert - Should report XPC4004 (modern API takes precedence)
-        var xpc4004Diagnostics = diagnostics
-            .Where(d => d.Id == "XPC4004")
+        // Assert - Should report XPC3003 (modern API takes precedence)
+        var xpc3003Diagnostics = diagnostics
+            .Where(d => d.Id == "XPC3003")
             .ToArray();
 
-        var xpc4005Diagnostics = diagnostics
-            .Where(d => d.Id == "XPC4005")
+        var xpc3002Diagnostics = diagnostics
+            .Where(d => d.Id == "XPC3002")
             .ToArray();
 
-        xpc4004Diagnostics.Should().NotBeEmpty("XPC4004 should be reported when modern API (WithPreImage) is used");
-        xpc4005Diagnostics.Should().BeEmpty("XPC4005 should NOT be reported when modern API is also present");
+        xpc3003Diagnostics.Should().NotBeEmpty("XPC3003 should be reported when modern API (WithPreImage) is used");
+        xpc3002Diagnostics.Should().BeEmpty("XPC3002 should NOT be reported when modern API is also present");
     }
 
     private static async Task<ImmutableArray<Diagnostic>> GetAnalyzerDiagnosticsAsync(string source, DiagnosticAnalyzer analyzer)

XrmPluginCore.SourceGenerator/AnalyzerReleases.Shipped.md

@@ -32,5 +32,32 @@ XPC4006 | XrmPluginCore.SourceGenerator | Error    | XPC4006 Handler signature m
 ### Changed Rules
 
 Rule ID | New Category | New Severity | Old Category | Old Severity | Notes
---------|--------------|--------------|--------------|--------------|-------|-------
+--------|--------------|--------------|--------------|--------------|-------
 XPC4003 | XrmPluginCore.SourceGenerator | Warning | XrmPluginCore.SourceGenerator | Error | Handler signature does not match registered images (generated types don't exist)
+
+## Release 1.2.3
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+XPC1001 | XrmPluginCore.SourceGenerator | Info | Generated type-safe wrapper classes (replaces XPC1000)
+XPC2001 | XrmPluginCore.SourceGenerator | Warning | No parameterless constructor found (renumbered from XPC4001)
+XPC3002 | XrmPluginCore.SourceGenerator | Info | Consider using modern image registration API (renumbered from XPC4005)
+XPC3003 | XrmPluginCore.SourceGenerator | Warning | Image registration without method reference (renumbered from XPC4004)
+XPC4001 | XrmPluginCore.SourceGenerator | Error | Handler method not found (renumbered from XPC4002)
+XPC4002 | XrmPluginCore.SourceGenerator | Warning | Handler signature mismatch - types don't exist (renumbered from XPC4003)
+XPC4003 | XrmPluginCore.SourceGenerator | Error | Handler signature mismatch - types exist (renumbered from XPC4006)
+XPC5001 | XrmPluginCore.SourceGenerator | Warning | Failed to resolve symbol (renumbered from XPC4000)
+XPC5002 | XrmPluginCore.SourceGenerator | Error | Failed to generate wrapper classes (renumbered from XPC5000)
+
+### Removed Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+XPC1000 | XrmPluginCore.SourceGenerator | Info | Replaced by XPC1001
+XPC4000 | XrmPluginCore.SourceGenerator | Warning | Replaced by XPC5001
+XPC4004 | XrmPluginCore.SourceGenerator | Warning | Replaced by XPC3003
+XPC4005 | XrmPluginCore.SourceGenerator | Info | Replaced by XPC3002
+XPC4006 | XrmPluginCore.SourceGenerator | Error | Replaced by XPC4003
+XPC5000 | XrmPluginCore.SourceGenerator | Error | Replaced by XPC5002

XrmPluginCore.SourceGenerator/Analyzers/HandlerSignatureMismatchAnalyzer.cs

@@ -1,16 +1,10 @@
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-using System.Collections.Immutable;
-using System.Linq;
 using XrmPluginCore.SourceGenerator.Helpers;
 
 namespace XrmPluginCore.SourceGenerator.Analyzers;
 
 /// <summary>
 /// Analyzer that reports when a handler method signature does not match the registered images.
-/// Reports XPC4003 (Warning) when generated types don't exist yet, XPC4006 (Error) when they do.
+/// Reports XPC4002 (Warning) when generated types don't exist yet, XPC4003 (Error) when they do.
 /// </summary>
 [DiagnosticAnalyzer(LanguageNames.CSharp)]
 public class HandlerSignatureMismatchAnalyzer : DiagnosticAnalyzer
@@ -73,7 +67,7 @@ private void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
 		var methods = TypeHelper.GetAllMethodsIncludingInherited(serviceType, methodName);
 		if (!methods.Any())
 		{
-			return; // Method doesn't exist - XPC4002 handles this
+			return; // Method doesn't exist - XPC4001 handles this
 		}
 
 		// Check for registered images
@@ -103,7 +97,7 @@ private void AnalyzeInvocation(SyntaxNodeAnalysisContext context)
 			hasPreImage,
 			hasPostImage);
 
-		// Choose diagnostic: XPC4006 (Error) if types exist, XPC4003 (Warning) if they don't
+		// Choose diagnostic: XPC4003 (Error) if types exist, XPC4002 (Warning) if they don't
 		var descriptor = generatedTypesExist
 			? DiagnosticDescriptors.HandlerSignatureMismatchError
 			: DiagnosticDescriptors.HandlerSignatureMismatch;

XrmPluginCore.SourceGenerator/CHANGELOG.md

@@ -1,5 +1,6 @@
 ### v1.2.3 - 28 November 2025
 * Fix: Generate PreImage/PostImage types even when handler signature doesn't match (fixes chicken-and-egg problem where types couldn't be used until they existed)
+* Breaking: Reorganized diagnostic IDs by category (XPC1xxx=Info, XPC2xxx=Plugin structure, XPC3xxx=Style, XPC4xxx=Handler methods, XPC5xxx=Internal errors)
 
 ### v1.2.2 - 27 November 2025
 * Fix: XPC4003 has been reduced to Warning to allow initial build to succeed

XrmPluginCore.SourceGenerator/CodeFixes/AddParameterlessConstructorCodeFixProvider.cs

@@ -18,7 +18,7 @@ namespace XrmPluginCore.SourceGenerator.CodeFixes;
 public class AddParameterlessConstructorCodeFixProvider : CodeFixProvider
 {
 	public sealed override ImmutableArray<string> FixableDiagnosticIds =>
-		ImmutableArray.Create("XPC4001");
+		ImmutableArray.Create(DiagnosticDescriptors.NoParameterlessConstructor.Id);
 
 	public sealed override FixAllProvider GetFixAllProvider() =>
 		WellKnownFixAllProviders.BatchFixer;

XrmPluginCore.SourceGenerator/CodeFixes/CreateHandlerMethodCodeFixProvider.cs

@@ -19,7 +19,7 @@ namespace XrmPluginCore.SourceGenerator.CodeFixes;
 public class CreateHandlerMethodCodeFixProvider : CodeFixProvider
 {
 	public sealed override ImmutableArray<string> FixableDiagnosticIds =>
-		ImmutableArray.Create("XPC4002");
+		ImmutableArray.Create(DiagnosticDescriptors.HandlerMethodNotFound.Id);
 
 	public sealed override FixAllProvider GetFixAllProvider() =>
 		WellKnownFixAllProviders.BatchFixer;

XrmPluginCore.SourceGenerator/CodeFixes/FixHandlerSignatureCodeFixProvider.cs

@@ -19,7 +19,9 @@ namespace XrmPluginCore.SourceGenerator.CodeFixes;
 public class FixHandlerSignatureCodeFixProvider : CodeFixProvider
 {
 	public sealed override ImmutableArray<string> FixableDiagnosticIds =>
-		ImmutableArray.Create("XPC4003");
+		ImmutableArray.Create(
+			DiagnosticDescriptors.HandlerSignatureMismatch.Id,
+			DiagnosticDescriptors.HandlerSignatureMismatchError.Id);
 
 	public sealed override FixAllProvider GetFixAllProvider() =>
 		WellKnownFixAllProviders.BatchFixer;