Add warning handling during interface generation and extend localized resources

Author: NikolayPianikov

DIAGNOSTICS.md

@@ -376,6 +376,27 @@ example scenarios. IDs and anchors are stable; message text is localized.
 - See: [dependent-compositions](readme/dependent-compositions.md).
 - Examples: Binding in a dependent setup uses instance field/property.
 
+### DIW008
+- Description: GenerateInterface is applied to a non-public element.
+- Problem: `[GenerateInterface]` was placed on a non-public method/property/event.
+- Fix: Make the element `public` or remove the attribute from that element.
+- See: [generate-interface](readme/generate-interface.md).
+- Examples: `[GenerateInterface]` on `private` or `internal` property.
+
+### DIW009
+- Description: GenerateInterface is applied to a static element.
+- Problem: `[GenerateInterface]` was placed on a `static` method/property/event.
+- Fix: Move the contract element to an instance member or remove the attribute.
+- See: [generate-interface](readme/generate-interface.md).
+- Examples: `[GenerateInterface]` on `public static` method.
+
+### DIW010
+- Description: Selective interface generation produced an empty interface.
+- Problem: Selective mode was enabled for an interface, but no eligible elements remained after filtering.
+- Fix: Mark at least one `public` instance element for that interface, or remove selective member annotations.
+- See: [generate-interface](readme/generate-interface.md).
+- Examples: All selected elements are `IgnoreInterface`, non-public, or static.
+
 ## Info
 
 ### DII000

src/Pure.DI.Core/Core/LogId.cs

@@ -111,6 +111,12 @@ static class LogId
     public const string WarningTypeArgInResolveMethod = "DIW006";
     // DependsOn uses an instance member.
     public const string WarningInstanceMemberInDependsOnSetup = "DIW007";
+    // GenerateInterface attribute is used on a non-public element.
+    public const string WarningGenerateInterfaceOnNonPublicMember = "DIW008";
+    // GenerateInterface attribute is used on a static element.
+    public const string WarningGenerateInterfaceOnStaticMember = "DIW009";
+    // Selective interface generation produced an empty interface.
+    public const string WarningGenerateInterfaceSelectiveEmpty = "DIW010";
 
     // Info
     // Generation was interrupted.

src/Pure.DI.Core/Core/LogMetadata.cs

@@ -61,6 +61,9 @@ static class LogMetadata
             LogId.WarningRootArgInResolveMethod => $"{HelpLinkBaseUrl}#diw005",
             LogId.WarningTypeArgInResolveMethod => $"{HelpLinkBaseUrl}#diw006",
             LogId.WarningInstanceMemberInDependsOnSetup => $"{HelpLinkBaseUrl}#diw007",
+            LogId.WarningGenerateInterfaceOnNonPublicMember => $"{HelpLinkBaseUrl}#diw008",
+            LogId.WarningGenerateInterfaceOnStaticMember => $"{HelpLinkBaseUrl}#diw009",
+            LogId.WarningGenerateInterfaceSelectiveEmpty => $"{HelpLinkBaseUrl}#diw010",
             LogId.InfoGenerationInterrupted => $"{HelpLinkBaseUrl}#dii000",
             LogId.InfoNotImplementedContract => $"{HelpLinkBaseUrl}#dii001",
             _ => null
@@ -125,6 +128,9 @@ public static string GetCategory(string id) =>
             LogId.ErrorInvalidAttributeArgumentPosition => "Validation",
             LogId.ErrorAttributeMemberCannotBeProcessed => "Validation",
             LogId.WarningInjectionSiteNotUsed => "Validation",
+            LogId.WarningGenerateInterfaceOnNonPublicMember => "Validation",
+            LogId.WarningGenerateInterfaceOnStaticMember => "Validation",
+            LogId.WarningGenerateInterfaceSelectiveEmpty => "Validation",
 
             // ReSharper disable once RedundantSwitchExpressionArms
             LogId.InfoGenerationInterrupted => "General",
@@ -188,6 +194,9 @@ public static string GetCategory(string id) =>
             LogId.WarningRootArgInResolveMethod => Strings.Description_WarningRootArgInResolveMethod,
             LogId.WarningTypeArgInResolveMethod => Strings.Description_WarningTypeArgInResolveMethod,
             LogId.WarningInstanceMemberInDependsOnSetup => Strings.Description_WarningInstanceMemberInDependsOnSetup,
+            LogId.WarningGenerateInterfaceOnNonPublicMember => Strings.Description_WarningGenerateInterfaceOnNonPublicMember,
+            LogId.WarningGenerateInterfaceOnStaticMember => Strings.Description_WarningGenerateInterfaceOnStaticMember,
+            LogId.WarningGenerateInterfaceSelectiveEmpty => Strings.Description_WarningGenerateInterfaceSelectiveEmpty,
             LogId.InfoGenerationInterrupted => Strings.Description_InfoGenerationInterrupted,
             LogId.InfoNotImplementedContract => Strings.Description_InfoNotImplementedContract,
             LogId.ErrorUnhandled => Strings.Description_ErrorUnhandled,

src/Pure.DI.Core/InterfaceGeneration/GeneratedInterfaceWarning.cs

@@ -0,0 +1,16 @@
+namespace Pure.DI.InterfaceGeneration;
+
+sealed class GeneratedInterfaceWarning(
+    string id,
+    string message,
+    string messageKey,
+    Location location)
+{
+    public string Id { get; } = id;
+
+    public string Message { get; } = message;
+
+    public string MessageKey { get; } = messageKey;
+
+    public Location Location { get; } = location;
+}

src/Pure.DI.Core/InterfaceGeneration/GeneratedInterfacesResult.cs

@@ -0,0 +1,10 @@
+namespace Pure.DI.InterfaceGeneration;
+
+sealed class GeneratedInterfacesResult(
+    ImmutableArray<GeneratedInterfaceSource> sources,
+    ImmutableArray<GeneratedInterfaceWarning> warnings)
+{
+    public ImmutableArray<GeneratedInterfaceSource> Sources { get; } = sources;
+
+    public ImmutableArray<GeneratedInterfaceWarning> Warnings { get; } = warnings;
+}

src/Pure.DI.Core/InterfaceGeneration/IInterfaceBuilder.cs

@@ -2,7 +2,7 @@
 
 interface IInterfaceBuilder
 {
-    ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
+    GeneratedInterfacesResult BuildInterfacesFor(
         SemanticModel semanticModel,
         ITypeSymbol typeSymbol,
         ClassDeclarationSyntax classSyntax);

src/Pure.DI.Core/InterfaceGeneration/InterfaceBuilder.cs

@@ -14,6 +14,7 @@ sealed class InterfaceBuilder(
     IRoslynSymbols roslynSymbols,
     ITypes types,
     IArguments arguments,
+    ILocationProvider locationProvider,
     Func<IBuilder<GeneratedInterfaceDetails, Lines>> interfaceCodeBuilderFactory)
     : IInterfaceBuilder
 {
@@ -35,14 +36,16 @@ sealed class InterfaceBuilder(
         globalNamespaceStyle: FullyQualifiedDisplayFormat.GlobalNamespaceStyle,
         miscellaneousOptions: FullyQualifiedDisplayFormat.MiscellaneousOptions);
 
-    public ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
+    public GeneratedInterfacesResult BuildInterfacesFor(
         SemanticModel semanticModel,
         ITypeSymbol typeSymbol,
         ClassDeclarationSyntax classSyntax)
     {
         if (typeSymbol is not INamedTypeSymbol namedTypeSymbol)
         {
-            return ImmutableArray<GeneratedInterfaceSource>.Empty;
+            return new GeneratedInterfacesResult(
+                ImmutableArray<GeneratedInterfaceSource>.Empty,
+                ImmutableArray<GeneratedInterfaceWarning>.Empty);
         }
 
         var generateInterfaceAttributeFullName = $"{Names.GlobalNamespacePrefix}{Names.GenerateInterfaceAttributeFullName}";
@@ -53,6 +56,8 @@ public ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
         var settingsByInterface = new Dictionary<InterfaceKey, (bool AsInternal, bool HasClassAttribute)>();
         var selectiveInterfaces = new HashSet<InterfaceKey>();
         var selectedMembersByInterface = new Dictionary<InterfaceKey, HashSet<ISymbol>>();
+        var selectiveInterfaceLocations = new Dictionary<InterfaceKey, Location>();
+        var warnings = new List<GeneratedInterfaceWarning>();
 
         var classGenerateAttributes = typeSymbol.GetAttributes()
             .Where(x => x.AttributeClass?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) == generateInterfaceAttributeFullName)
@@ -76,12 +81,15 @@ public ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
             settingsByInterface[key] = (existing.AsInternal, true);
         }
 
-        var members = roslynSymbols.GetAllMembers(typeSymbol)
+        var allMembers = roslynSymbols.GetAllMembers(typeSymbol)
+            .Where(x => x.Kind is SymbolKind.Method or SymbolKind.Property or SymbolKind.Event)
+            .ToList();
+        var eligibleMembers = allMembers
             .Where(x => x.DeclaredAccessibility == Accessibility.Public)
             .Where(x => !x.IsStatic)
             .ToList();
 
-        foreach (var member in members)
+        foreach (var member in allMembers)
         {
             var generationAttributes = member.GetAttributes()
                 .Where(x => x.AttributeClass?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat) == generateInterfaceAttributeFullName)
@@ -101,12 +109,38 @@ public ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
                     defaultAsInternal);
                 var key = new InterfaceKey(settings.namespaceName, settings.interfaceName);
                 selectiveInterfaces.Add(key);
+                if (!selectiveInterfaceLocations.ContainsKey(key))
+                {
+                    selectiveInterfaceLocations.Add(key, GetLocation(member, generationAttribute));
+                }
 
                 if (!settingsByInterface.TryGetValue(key, out var existing))
                 {
                     settingsByInterface[key] = (settings.asInternal, false);
                 }
 
+                var memberName = member.ToDisplayString(SymbolDisplayFormat.CSharpErrorMessageFormat);
+                var interfaceDisplayName = GetInterfaceDisplayName(key);
+                if (member.IsStatic)
+                {
+                    warnings.Add(new GeneratedInterfaceWarning(
+                        LogId.WarningGenerateInterfaceOnStaticMember,
+                        string.Format(Strings.Warning_Template_GenerateInterfaceOnStaticMember, memberName, interfaceDisplayName),
+                        nameof(Strings.Warning_Template_GenerateInterfaceOnStaticMember),
+                        GetLocation(member, generationAttribute)));
+                    continue;
+                }
+
+                if (member.DeclaredAccessibility != Accessibility.Public)
+                {
+                    warnings.Add(new GeneratedInterfaceWarning(
+                        LogId.WarningGenerateInterfaceOnNonPublicMember,
+                        string.Format(Strings.Warning_Template_GenerateInterfaceOnNonPublicMember, memberName, interfaceDisplayName),
+                        nameof(Strings.Warning_Template_GenerateInterfaceOnNonPublicMember),
+                        GetLocation(member, generationAttribute)));
+                    continue;
+                }
+
                 if (HasIgnoreAttribute(member))
                 {
                     continue;
@@ -124,7 +158,9 @@ public ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
 
         if (settingsByInterface.Count == 0)
         {
-            return ImmutableArray<GeneratedInterfaceSource>.Empty;
+            return new GeneratedInterfacesResult(
+                ImmutableArray<GeneratedInterfaceSource>.Empty,
+                warnings.ToImmutableArray());
         }
 
         var nullableContextEnabled = semanticModel.Compilation.Options.NullableContextOptions != NullableContextOptions.Disable;
@@ -135,11 +171,21 @@ public ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
             var settings = pair.Value;
             var interfaceMembers = selectiveInterfaces.Contains(key)
                 ? selectedMembersByInterface.TryGetValue(key, out var selectedMembers)
-                    ? members.Where(selectedMembers.Contains).ToList()
+                    ? eligibleMembers.Where(selectedMembers.Contains).ToList()
                     : []
                 : settings.HasClassAttribute
-                    ? members.Where(x => !HasIgnoreAttribute(x)).ToList()
+                    ? eligibleMembers.Where(x => !HasIgnoreAttribute(x)).ToList()
                     : [];
+            if (selectiveInterfaces.Contains(key)
+                && interfaceMembers.Count == 0
+                && selectiveInterfaceLocations.TryGetValue(key, out var selectiveLocation))
+            {
+                warnings.Add(new GeneratedInterfaceWarning(
+                    LogId.WarningGenerateInterfaceSelectiveEmpty,
+                    string.Format(Strings.Warning_Template_GenerateInterfaceSelectiveEmpty, GetInterfaceDisplayName(key)),
+                    nameof(Strings.Warning_Template_GenerateInterfaceSelectiveEmpty),
+                    selectiveLocation));
+            }
 
             var symbolDetails = new GeneratedInterfaceDetails(semanticModel, key.NamespaceName, key.InterfaceName, settings.AsInternal)
             {
@@ -156,7 +202,7 @@ public ImmutableArray<GeneratedInterfaceSource> BuildInterfacesFor(
                 interfaceCodeBuilderFactory().Build(symbolDetails)));
         }
 
-        return generatedSources.ToImmutable();
+        return new GeneratedInterfacesResult(generatedSources.ToImmutable(), warnings.ToImmutableArray());
     }
 
     private ImmutableArray<MethodInfo> GetMethods(SemanticModel semanticModel, List<ISymbol> members, bool nullableContextEnabled)
@@ -403,4 +449,19 @@ private static T GetArgValue<T>(SemanticModel semanticModel, IReadOnlyList<Attri
         return value is { HasValue: true, Value: T typedValue } ? typedValue : defaultValue;
     }
 
+    private Location GetLocation(ISymbol member, AttributeData attribute)
+    {
+        if (attribute.ApplicationSyntaxReference?.GetSyntax() is AttributeSyntax attributeSyntax)
+        {
+            return locationProvider.GetLocation(attributeSyntax);
+        }
+
+        return member.Locations.FirstOrDefault() ?? Location.None;
+    }
+
+    private static string GetInterfaceDisplayName(InterfaceKey key) =>
+        string.IsNullOrWhiteSpace(key.NamespaceName)
+            ? key.InterfaceName
+            : $"{key.NamespaceName}.{key.InterfaceName}";
+
 }

src/Pure.DI.Core/InterfaceGeneration/InterfaceGenerator.cs

@@ -7,6 +7,7 @@ namespace Pure.DI.InterfaceGeneration;
 using Microsoft.CodeAnalysis.Text;
 using Pure.DI;
 using CoreNames = Pure.DI.Core.Names;
+using static Pure.DI.Core.LogMetadata;
 
 sealed class InterfaceGenerator(IInterfaceBuilder interfaceBuilder) : IInterfaceGenerator
 {
@@ -37,7 +38,13 @@ public void Generate(SourceProductionContext context, ImmutableArray<GeneratorSy
                 continue;
             }
 
-            var generatedInterfaces = interfaceBuilder.BuildInterfacesFor(syntaxContext.SemanticModel, typeSymbol, classSyntax);
+            var generatedInterfacesResult = interfaceBuilder.BuildInterfacesFor(syntaxContext.SemanticModel, typeSymbol, classSyntax);
+            foreach (var warning in generatedInterfacesResult.Warnings)
+            {
+                ReportWarning(context, warning);
+            }
+
+            var generatedInterfaces = generatedInterfacesResult.Sources;
             if (generatedInterfaces.IsDefaultOrEmpty)
             {
                 continue;
@@ -101,4 +108,19 @@ private static string SanitizeFileNamePart(string value) => string.IsNullOrWhite
             .Replace(',', '_')
             .Replace(' ', '_')
             .Replace(':', '_');
+
+    private static void ReportWarning(SourceProductionContext context, GeneratedInterfaceWarning warning)
+    {
+        var descriptor = new DiagnosticDescriptor(
+            warning.Id,
+            "WRN",
+            warning.Message,
+            GetCategory(warning.Id),
+            DiagnosticSeverity.Warning,
+            isEnabledByDefault: true,
+            description: GetDescription(warning.Id),
+            helpLinkUri: GetHelpLink(warning.Id));
+        var properties = ImmutableDictionary<string, string?>.Empty.Add("puredi.messageKey", warning.MessageKey);
+        context.ReportDiagnostic(Diagnostic.Create(descriptor, warning.Location, properties));
+    }
 }