The Bind method without parameters should only add bindings to first-…

…level abstractions for the type

src/Pure.DI.Core/Core/BaseSymbolsProvider.cs

@@ -14,7 +14,7 @@ public IEnumerable<ITypeSymbol> GetBaseSymbols(ITypeSymbol symbol, int deep = in
         while (true)
         {
             yield return symbol;
-            foreach (var type in symbol.AllInterfaces.SelectMany(i => GetBaseSymbols(i, deep)))
+            foreach (var type in symbol.Interfaces.SelectMany(i => GetBaseSymbols(i, deep)))
             {
                 yield return type;
             }

src/Pure.DI.Core/Core/Code/VariablesBuilder.cs

@@ -28,6 +28,11 @@ public Block Build(
             var stack = new Stack<IStatement>(currentBlock.Statements);
             while (stack.TryPop(out var currentStatement))
             {
+                if (stack.Count > 0xffff)
+                {
+                    throw new CompileErrorException($"Cyclic dependency has been found.", rootNode.Binding.Source.GetLocation(), LogId.ErrorCyclicDependency);
+                }
+
                 switch (currentStatement)
                 {
                     case Block block:

tests/Pure.DI.IntegrationTests/GenericRootsTests.cs

@@ -549,4 +549,85 @@ public static void Main()
         result.Success.ShouldBeTrue(result);
         result.StdOut.ShouldBe(["2"], result);
     }
+
+    [Fact]
+    public async Task ShouldSupportGenericRootWithTags()
+    {
+        // Given
+
+        // When
+        var result = await """
+using System;
+using System.Linq;
+using Pure.DI;
+using static Pure.DI.Lifetime;
+
+namespace Sample
+{
+    interface IRunner<T>
+    {
+        T Run(T value);
+    }
+
+    interface IPipeline<T> : IRunner<T>
+    {
+    }
+
+    class Pipeline<T> : IPipeline<T>
+    {
+        private readonly IRunner<T>[] _runners;
+
+        public Pipeline(params IRunner<T>[] runners)
+        {
+            _runners = runners;
+        }
+
+        public T Run(T value) => 
+            _runners.Aggregate(
+                value,
+                (current, handler) => handler.Run(current));
+    }
+
+    class Tracer<T>: IRunner<T>
+    {
+        public T Run(T value)
+        {
+            Console.WriteLine(value);
+            return value;
+        }
+    }
+
+    class SquareRootCalculator: IRunner<decimal>
+    {
+        public decimal Run(decimal value) => 
+            value * value;
+    }
+
+    internal partial class Composition
+    {
+        void Setup()
+        {
+            DI.Setup(nameof(Composition))
+                .Bind(0).To<Tracer<TT>>()
+                .Bind(1).To<SquareRootCalculator>()
+                .Bind(2).To<Tracer<TT>>()
+                .Bind().To<Pipeline<TT>>()
+                .Root<Pipeline<decimal>>("Pipeline");
+        }
+    }
+
+    public class Program
+    {
+        public static void Main()
+        {
+            new Composition().Pipeline.Run(7);
+        }
+    }                
+}
+""".RunAsync(new Options(LanguageVersion.CSharp9));
+
+        // Then
+        result.Success.ShouldBeTrue(result);
+        result.StdOut.ShouldBe(["7", "49"], result);
+    }
 }