More precise definition of cyclic dependencies

Author: NikolayPianikov

src/Pure.DI.Core/Core/CyclicDependenciesValidator.cs

@@ -3,19 +3,20 @@
 namespace Pure.DI.Core;
 
 sealed class CyclicDependenciesValidator(
-    IGraphWalker<HashSet<object>, ImmutableArray<Dependency>> graphWalker,
-    [Tag(typeof(CyclicDependencyValidatorVisitor))] IGraphVisitor<HashSet<object>, ImmutableArray<Dependency>> visitor,
+    IGraphWalker<CyclicDependenciesValidatorContext, ImmutableArray<Dependency>> graphWalker,
+    [Tag(typeof(CyclicDependencyValidatorVisitor))] IGraphVisitor<CyclicDependenciesValidatorContext, ImmutableArray<Dependency>> visitor,
     CancellationToken cancellationToken)
     : IValidator<DependencyGraph>
 {
     public bool Validate(DependencyGraph dependencyGraph)
     {
         var graph = dependencyGraph.Graph;
         var errors = new HashSet<object>();
+        var ctx = new CyclicDependenciesValidatorContext(dependencyGraph, errors);
         foreach (var root in dependencyGraph.Roots)
         {
             graphWalker.Walk(
-                errors,
+                ctx,
                 graph,
                 root.Node,
                 visitor,

src/Pure.DI.Core/Core/CyclicDependencyValidatorVisitor.cs

@@ -1,10 +1,13 @@
 namespace Pure.DI.Core;
 
+using static Lifetime;
+
 sealed class CyclicDependencyValidatorVisitor(
     ILogger logger,
     INodeInfo nodeInfo,
-    ILocationProvider locationProvider)
-    : IGraphVisitor<HashSet<object>, ImmutableArray<Dependency>>
+    ILocationProvider locationProvider,
+    ITypeResolver typeResolver)
+    : IGraphVisitor<CyclicDependenciesValidatorContext, ImmutableArray<Dependency>>
 {
     public ImmutableArray<Dependency> Create(
         IGraph<DependencyNode, Dependency> graph,
@@ -21,7 +24,7 @@ public ImmutableArray<Dependency> Append(
             : parent.Add(dependency);
 
     public bool Visit(
-        HashSet<object> errors,
+        CyclicDependenciesValidatorContext ctx,
         IGraph<DependencyNode, Dependency> graph,
         in ImmutableArray<Dependency> path)
     {
@@ -35,7 +38,7 @@ public bool Visit(
         foreach (var dependency in path)
         {
             var source = dependency.Source;
-            if (nodeInfo.IsLazy(source))
+            if (source.Lifetime is Singleton or Scoped or PerResolve or PerBlock && nodeInfo.IsLazy(source))
             {
                 nodes.Clear();
             }
@@ -45,12 +48,12 @@ public bool Visit(
                 continue;
             }
 
-            if (!errors.Add(path))
+            if (!ctx.Errors.Add(path))
             {
                 continue;
             }
 
-            var pathStr = string.Join(" <-- ", path.Select(i => i.Source.Type));
+            var pathStr = string.Join(" <-- ", path.Select(i => typeResolver.Resolve(ctx.DependencyGraph.Source, i.Source.Type).Name.Replace("global::", "")));
             var locations = (dependency.Injection.Locations.IsDefault ? ImmutableArray<Location>.Empty : dependency.Injection.Locations)
                 .AddRange(path.SelectMany(i => i.Injection.Locations.IsDefault ? ImmutableArray<Location>.Empty : i.Injection.Locations))
                 .Add(locationProvider.GetLocation(source.Binding.Source));

src/Pure.DI.Core/Core/Models/CyclicDependenciesValidatorContext.cs

@@ -0,0 +1,5 @@
+namespace Pure.DI.Core.Models;
+
+record CyclicDependenciesValidatorContext(
+    DependencyGraph DependencyGraph,
+    HashSet<object> Errors);

tests/Pure.DI.IntegrationTests/ErrorsAndWarningsTests.cs

@@ -515,6 +515,71 @@ public class Program { public static void Main() { } }
         result.Errors.Count(i => i.Id == LogId.ErrorCyclicDependency && i.Locations.FirstOrDefault().GetSource() == "dep").ShouldBe(1, result);
     }
 
+    [Fact]
+    public async Task ShouldHandleCyclicDependenciesWhenFactory()
+    {
+        // Given
+
+        // When
+        var result = await """
+                           namespace Sample
+                           {
+                               using System;
+                               using System.Collections.Generic;
+                               using Pure.DI;
+                               using Sample;
+                           
+                               public interface IStartupStep
+                               {
+                                   void Start();
+                               }
+                               
+                               public class StartupStep : IStartupStep
+                               {
+                                   public void Start()
+                                   {
+                                   }
+                               }
+                               
+                               public class StepsConsumer : IStartupStep
+                               {
+                                   private readonly IEnumerable<Func<IStartupStep>> _stepsFactory;
+                               
+                                   public StepsConsumer(IEnumerable<Func<IStartupStep>> stepsFactory)
+                                   {
+                                       _stepsFactory = stepsFactory;
+                                   }
+                               
+                                   public void Start()
+                                   {
+                                       foreach (var step in _stepsFactory)
+                                       {
+                                           step();
+                                       }
+                                   }
+                               }
+                           
+                               internal partial class Composition
+                               {
+                                   private void Setup() =>
+                                       DI.Setup("Composition")
+                                           .Bind().To<StartupStep>()
+                                           .Bind().To(ctx => {
+                                               ctx.Inject(out Func<IStartupStep> factory);
+                                               return factory;
+                                           })
+                                           .Root<StepsConsumer>("Consumer");
+                               }
+                           
+                               public class Program { public static void Main() { } }
+                           }
+                           """.RunAsync();
+
+        // Then
+        result.Success.ShouldBeFalse(result);
+        result.Errors.Count(i => i.Id == LogId.ErrorCyclicDependency && i.Locations.FirstOrDefault().GetSource() == "Func<IStartupStep> factory").ShouldBe(1, result);
+    }
+
     [Fact]
     public async Task ShouldShowErrorWhenUnresolvedDependency()
     {