Support for generic builders and roots

Author: NikolayPianikov

src/Pure.DI.Core/Core/ApiInvocationProcessor.cs

@@ -292,10 +292,17 @@ MemberAccessExpressionSyntax memberAccess when memberAccess.Kind() == SyntaxKind
                         var rootsArgs = arguments.GetArgs(invocation.ArgumentList, "name", "kind");
                         var rootsName = rootsArgs[0] is { } nameArg ? semantic.GetConstantValue<string>(semanticModel, nameArg.Expression) ?? "" : "";
                         var kind = rootsArgs[1] is { } kindArg ? semantic.GetConstantValue<RootKinds>(semanticModel, kindArg.Expression) : RootKinds.Default;
+                        var hasRootsType = false;
                         foreach (var rootType in GetRelatedTypes(semanticModel, invocation, rootsType))
                         {
                             var rootName = GetName((SyntaxNode?)rootsArgs[1] ?? invocation, rootsName, rootType) ?? "";
                             metadataVisitor.VisitRoot(new MdRoot(invocation, semanticModel, rootType, rootName, new MdTag(0, null), kind, invocationComments, false));
+                            hasRootsType = true;
+                        }
+
+                        if (!hasRootsType)
+                        {
+                            throw new CompileErrorException($"No type that inherits from {symbolNames.GetName(rootsType)} was found.", invocation.GetLocation(), LogId.ErrorInvalidMetadata);
                         }
 
                         break;
@@ -319,6 +326,7 @@ MemberAccessExpressionSyntax memberAccess when memberAccess.Kind() == SyntaxKind
                             throw new CompileErrorException("Invalid builders type.", invocation.GetLocation(), LogId.ErrorInvalidMetadata);
                         }
 
+                        var hasBuildersType = false;
                         foreach (var builderType in GetRelatedTypes(semanticModel, invocation, buildersRootType))
                         {
                             VisitBuilder(
@@ -328,6 +336,13 @@ MemberAccessExpressionSyntax memberAccess when memberAccess.Kind() == SyntaxKind
                                 buildersRootTypeSyntax,
                                 builderType,
                                 invocationComments);
+
+                            hasBuildersType = true;
+                        }
+
+                        if (!hasBuildersType)
+                        {
+                            throw new CompileErrorException($"No type that inherits from {symbolNames.GetName(buildersRootType)} was found.", invocation.GetLocation(), LogId.ErrorInvalidMetadata);
                         }
 
                         break;

tests/Pure.DI.IntegrationTests/BuildersTests.cs

@@ -1,5 +1,7 @@
 namespace Pure.DI.IntegrationTests;
 
+using Core;
+
 public class BuildersTests
 {
     [Fact]
@@ -563,4 +565,52 @@ public static void Main()
         result.Success.ShouldBeTrue(result);
         result.StdOut.ShouldBe(["Initialize 1 Abc", "Initialize 2 Abc"], result);
     }
+
+    [Fact]
+    public async Task ShouldShowErrorWhenInheritedTypeNotFound()
+    {
+        // Given
+
+        // When
+        var result = await """
+                           using System;
+                           using Pure.DI;
+
+                           namespace Sample
+                           {
+                               interface IDependency {}
+                           
+                               class Dependency: IDependency
+                               {
+                               }
+                           
+                               interface IService
+                               {
+                                   IDependency? Dep { get; }
+                               }
+                               
+                               static class Setup
+                               {
+                                   private static void SetupComposition()
+                                   {
+                                       DI.Setup("Composition")
+                                           .Bind().To<Dependency>()
+                                           .Builders<IService>();
+                                   }
+                               }
+                           
+                               public class Program
+                               {
+                                   public static void Main()
+                                   {
+                                       var composition = new Composition();
+                                   }
+                               }
+                           }
+                           """.RunAsync();
+
+        // Then
+        result.Success.ShouldBeFalse(result);
+        result.Errors.Count(i => i.Id == LogId.ErrorInvalidMetadata).ShouldBe(1, result);
+    }
 }

tests/Pure.DI.IntegrationTests/RootsTests.cs

@@ -1,5 +1,7 @@
 namespace Pure.DI.IntegrationTests;
 
+using Core;
+
 public class RootsTests
 {
     [Fact]
@@ -404,4 +406,52 @@ public static void Main()
         result.Success.ShouldBeTrue(result);
         result.StdOut.ShouldBe(["Initialize 1 Abc", "Initialize 2 Abc", "Initialize 1 Abc", "Initialize 2 Abc"], result);
     }
+
+    [Fact]
+    public async Task ShouldShowErrorWhenInheritedTypeNotFound()
+    {
+        // Given
+
+        // When
+        var result = await """
+                           using System;
+                           using Pure.DI;
+
+                           namespace Sample
+                           {
+                               interface IDependency {}
+                           
+                               class Dependency: IDependency
+                               {
+                               }
+                           
+                               interface IService
+                               {
+                                   IDependency? Dep { get; }
+                               }
+                           
+                               static class Setup
+                               {
+                                   private static void SetupComposition()
+                                   {
+                                       DI.Setup("Composition")
+                                           .Bind().To<Dependency>()
+                                           .Roots<IService>();
+                                   }
+                               }
+                           
+                               public class Program
+                               {
+                                   public static void Main()
+                                   {
+                                       var composition = new Composition();
+                                   }
+                               }
+                           }
+                           """.RunAsync();
+
+        // Then
+        result.Success.ShouldBeFalse(result);
+        result.Errors.Count(i => i.Id == LogId.ErrorInvalidMetadata).ShouldBe(1, result);
+    }
 }