Add configuration path to NCDI001 diagnostic (#89)

Add configuration path to NCDI001 diagnostic (#88)

NCDI001 now reports the root configuration type and the configuration path the non-hot-reloadable type is bound at, so types buried in a complex config graph can be traced to where they are referenced.

Author: roryprimrose

Neovolve.Configuration.DependencyInjection.Generator.UnitTests/ConfigureWithGeneratorTests.cs

@@ -376,12 +376,14 @@ public void ReportsNotHotReloadableForStructConfigType()
 
         harness.GeneratorDiagnostics.Should()
             .Contain(diagnostic => diagnostic.Id == "NCDI001"
-                && diagnostic.GetMessage().Contains("Sample.SettingsStruct"));
+                && diagnostic.GetMessage().Contains("Sample.SettingsStruct")
+                && diagnostic.GetMessage().Contains("Sample.RootConfig")
+                && diagnostic.GetMessage().Contains("Settings"));
 
-        // The root is not hot reloaded, so it is never reported.
+        // The root is not hot reloaded, so it is never reported as the not hot reloadable type.
         harness.GeneratorDiagnostics.Should()
             .NotContain(diagnostic => diagnostic.Id == "NCDI001"
-                && diagnostic.GetMessage().Contains("Sample.RootConfig"));
+                && diagnostic.GetMessage().Contains("'Sample.RootConfig' cannot be hot reloaded"));
     }
 
     [Fact]
@@ -411,7 +413,46 @@ public static class Caller
         harness.GeneratorDiagnostics.Should()
             .Contain(diagnostic => diagnostic.Id == "NCDI001"
                 && diagnostic.GetMessage().Contains("Sample.ChildRecord")
-                && diagnostic.GetMessage().Contains("no writable properties"));
+                && diagnostic.GetMessage().Contains("no writable properties")
+                && diagnostic.GetMessage().Contains("Sample.RootConfig")
+                && diagnostic.GetMessage().Contains("Child"));
+    }
+
+    [Fact]
+    public void ReportsNotHotReloadableWithNestedConfigurationPath()
+    {
+        const string source = @"
+namespace Sample
+{
+    using Microsoft.Extensions.Hosting;
+
+    public sealed record EndpointRecord(string Host, int Port);
+
+    public sealed class ServiceConfig
+    {
+        public EndpointRecord Endpoint { get; set; } = new(string.Empty, 0);
+        public string ServiceValue { get; set; } = string.Empty;
+    }
+
+    public sealed class RootConfig
+    {
+        public ServiceConfig Service { get; set; } = new();
+        public string RootValue { get; set; } = string.Empty;
+    }
+
+    public static class Caller
+    {
+        public static void Configure(IHostBuilder builder) => builder.ConfigureWith<RootConfig>();
+    }
+}";
+
+        var harness = GeneratorTestHarness.Run(source);
+
+        harness.GeneratorDiagnostics.Should()
+            .Contain(diagnostic => diagnostic.Id == "NCDI001"
+                && diagnostic.GetMessage().Contains("Sample.EndpointRecord")
+                && diagnostic.GetMessage().Contains("Service:Endpoint")
+                && diagnostic.GetMessage().Contains("Sample.RootConfig"));
     }
 
     [Fact]

Neovolve.Configuration.DependencyInjection.Generator/AnalyzerReleases.Unshipped.md

@@ -5,4 +5,4 @@
 
 Rule ID | Category | Severity | Notes
 --------|----------|----------|-------
-NCDI001 | Neovolve.Configuration | Warning | Configuration type cannot be hot reloaded (value type or no writable properties)
+NCDI001 | Neovolve.Configuration | Warning | Configuration type cannot be hot reloaded (value type or no writable properties); reports the root configuration type and the configuration path the type is bound at

Neovolve.Configuration.DependencyInjection.Generator/ConfigureWithGenerator.cs

@@ -103,6 +103,8 @@ private static void ReportNotHotReloadable(SourceProductionContext context, IEnu
 
         foreach (var root in roots)
         {
+            var pathsByType = BuildConfigPathLookup(root);
+
             foreach (var configType in root.ConfigTypes)
             {
                 if (configType.FullyQualifiedName == root.RootTypeFullyQualifiedName)
@@ -149,12 +151,59 @@ private static void ReportNotHotReloadable(SourceProductionContext context, IEnu
                     ? configType.FullyQualifiedName.Substring("global::".Length)
                     : configType.FullyQualifiedName;
 
+                var pathDescription = DescribeConfigPaths(root, configType.FullyQualifiedName, pathsByType);
+
                 context.ReportDiagnostic(Diagnostic.Create(
-                    DiagnosticDescriptors.NotHotReloadable, location, displayName, reason, fix));
+                    DiagnosticDescriptors.NotHotReloadable, location, displayName, reason, fix, pathDescription));
             }
         }
     }
 
+    private static Dictionary<string, List<string>> BuildConfigPathLookup(RootModel root)
+    {
+        var pathsByType = new Dictionary<string, List<string>>(StringComparer.Ordinal);
+
+        foreach (var registration in root.Registrations)
+        {
+            if (pathsByType.TryGetValue(registration.TypeFullyQualifiedName, out var paths) == false)
+            {
+                paths = new List<string>();
+                pathsByType[registration.TypeFullyQualifiedName] = paths;
+            }
+
+            if (paths.Contains(registration.SectionPath) == false)
+            {
+                paths.Add(registration.SectionPath);
+            }
+        }
+
+        return pathsByType;
+    }
+
+    private static string DescribeConfigPaths(RootModel root, string typeFullyQualifiedName,
+        Dictionary<string, List<string>> pathsByType)
+    {
+        if (pathsByType.TryGetValue(typeFullyQualifiedName, out var paths) == false
+            || paths.Count == 0)
+        {
+            return string.Empty;
+        }
+
+        var rootDisplay = root.RootTypeFullyQualifiedName.StartsWith("global::", StringComparison.Ordinal)
+            ? root.RootTypeFullyQualifiedName.Substring("global::".Length)
+            : root.RootTypeFullyQualifiedName;
+
+        var orderedPaths = paths.ToList();
+
+        orderedPaths.Sort(StringComparer.Ordinal);
+
+        var quotedPaths = string.Join("', '", orderedPaths);
+        var pathLabel = orderedPaths.Count == 1 ? "configuration path" : "configuration paths";
+
+        return $". It is bound under root configuration type '{rootDisplay}' at {pathLabel} '{quotedPaths}'";
+    }
+
+
     private static bool HasModuleInitializer(Compilation compilation)
     {
         var symbol = compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.ModuleInitializerAttribute");

Neovolve.Configuration.DependencyInjection.Generator/DiagnosticDescriptors.cs

@@ -20,7 +20,7 @@ internal static class DiagnosticDescriptors
         "NCDI001",
         "Configuration type cannot be hot reloaded",
         "Configuration type '{0}' cannot be hot reloaded because it {1}; injected instances will not receive "
-        + "configuration updates - {2}",
+        + "configuration updates - {2}{3}",
         Category,
         DiagnosticSeverity.Warning,
         isEnabledByDefault: true,

README.md

@@ -177,7 +177,7 @@ Hot reload works by updating the existing singleton instance of a configuration
 - **Value types** (`struct` and `record struct`). A struct is copied when it is injected, so updating the registered instance would not reach the copies already handed to application classes. Struct configuration types are bound and registered once as a snapshot of the configuration at startup, and they do not receive later updates.
 - **Reference types with no writable properties** (for example a positional `record` whose properties are all `init`-only). There is nowhere to write the updated values, so the injected instance keeps its startup values.
 
-The source generator reports these cases at compile time as warning **NCDI001** so the limitation is visible where the type is declared rather than failing silently at runtime. The accompanying code fix converts a `struct` (or `record struct`) configuration type into a class so it can hot reload. For a record with no writable properties, add settable properties or convert it to a mutable class.
+The source generator reports these cases at compile time as warning **NCDI001** so the limitation is visible where the type is declared rather than failing silently at runtime. The warning also reports the root configuration type and the configuration path the offending type is bound at (for example `Service:Endpoint`), so a type buried deep in a complex configuration graph can be traced back to where it is referenced. The accompanying code fix converts a `struct` (or `record struct`) configuration type into a class so it can hot reload. For a record with no writable properties, add settable properties or convert it to a mutable class.
 
 If a one-time snapshot is the intended behaviour for a given type, suppress the warning for that type: