Add virtual and override root kinds

Author: NikolayPianikov

src/Pure.DI.Core/Components/Api.g.cs

@@ -1378,7 +1378,7 @@ internal enum RootKinds
         Partial = 1 << 6,
 
         /// <summary>
-        /// Specifies to create a exposed root of the composition.
+        /// Specifies to create an exposed root of the composition.
         /// </summary>
         /// <seealso cref="BindAttribute"/>
         Exposed = 1 << 7,
@@ -1387,6 +1387,16 @@ internal enum RootKinds
         /// Specifies to use a <c>protected</c> access modifier for the root of the composition.
         /// </summary>
         Protected = 1 << 8,
+
+        /// <summary>
+        /// Specifies to use a <c>virtual</c> modifier for the root of the composition.
+        /// </summary>
+        Virtual = 1 << 9,
+        
+        /// <summary>
+        /// Specifies to use a <c>override</c> modifier for the root of the composition.
+        /// </summary>
+        Override = 1 << 10,
     }
 
     /// <summary>

src/Pure.DI.Core/Core/Code/Parts/RootMethodsBuilder.cs

@@ -83,6 +83,16 @@ private void BuildRoot(CompositionCode composition, Root root)
             name.Append(" partial");
         }
 
+        if ((root.Kind & RootKinds.Virtual) == RootKinds.Virtual)
+        {
+            name.Append(" virtual");
+        }
+
+        if ((root.Kind & RootKinds.Override) == RootKinds.Override)
+        {
+            name.Append(" override");
+        }
+
         name.Append(' ');
         name.Append(root.TypeDescription.Name);
 

src/Pure.DI.Core/Generator.cs

@@ -179,7 +179,7 @@ private void Setup() => DI.Setup()
             .Bind(UniqueTag).To<IdGenerator>()
             .Bind(GenericType).To<IdGenerator>()
             .Bind(Injection).To<IdGenerator>()
-            .Bind(Override).To<IdGenerator>()
+            .Bind(Tag.Override).To<IdGenerator>()
             .Bind().To<IdGenerator>()
             .Bind().To<Registry<TT>>()
             .Bind().To<Locks>()

tests/Pure.DI.IntegrationTests/RootsTests.cs

@@ -622,4 +622,134 @@ public static void Main()
         result.Success.ShouldBeTrue(result);
         result.StdOut.ShouldBe(["Initialize 1 Abc", "Initialize 1 Abc"], result);
     }
+
+    [Fact]
+    public async Task ShouldSupportVirtualRoot()
+    {
+        // Given
+
+        // When
+        var result = await """
+                           using System;
+                           using Pure.DI;
+
+                           namespace Sample
+                           {
+                               interface IDependency {}
+                           
+                               class Dependency: IDependency
+                               {
+                               }
+                           
+                               interface IService
+                               {
+                                   IDependency? Dep { get; }
+                               }
+                           
+                               class Service: IService 
+                               {
+                                   [Ordinal(1)]
+                                   internal void Initialize([Tag(374)] string depName)
+                                   {
+                                       Console.WriteLine($"Initialize 1 {depName}");
+                                   }
+                           
+                                   [Ordinal(0)]
+                                   public IDependency? Dep { get; set; }
+                               }
+                           
+                               static class Setup
+                               {
+                                   private static void SetupComposition()
+                                   {
+                                       DI.Setup("Composition")
+                                           .Bind(374).To(_ => "Abc")
+                                           .Bind().To<Dependency>()
+                                           .Root<Service>("MyService", kind: RootKinds.Virtual);
+                                   }
+                               }
+                           
+                               public class Program
+                               {
+                                   public static void Main()
+                                   {
+                                       var composition = new Composition();
+                                       var service = composition.MyService;
+                                   }
+                               }
+                           }
+                           """.RunAsync();
+
+        // Then
+        result.Success.ShouldBeTrue(result);
+        result.StdOut.ShouldBe(["Initialize 1 Abc"], result);
+    }
+
+    [Fact]
+    public async Task ShouldOverrideRoot()
+    {
+        // Given
+
+        // When
+        var result = await """
+                           using System;
+                           using Pure.DI;
+
+                           namespace Sample
+                           {
+                               interface IDependency {}
+                           
+                               class Dependency: IDependency
+                               {
+                               }
+                           
+                               interface IService
+                               {
+                                   IDependency? Dep { get; }
+                               }
+                           
+                               class Service: IService 
+                               {
+                                   [Ordinal(1)]
+                                   internal void Initialize([Tag(374)] string depName)
+                                   {
+                                       Console.WriteLine($"Initialize 1 {depName}");
+                                   }
+                           
+                                   [Ordinal(0)]
+                                   public IDependency? Dep { get; set; }
+                               }
+                               
+                               internal abstract class Composition
+                               {
+                                    internal abstract IService MyService { get; }
+                               }
+                           
+                               internal partial class OtherComposition: Composition
+                               {
+                                   private static void Setup()
+                                   {
+                                       DI.Setup()
+                                           .Bind(374).To(_ => "Abc")
+                                           .Bind().To<Dependency>()
+                                           .Bind().To<Service>()
+                                           .Root<IService>("MyService", kind: RootKinds.Internal | RootKinds.Override);
+                                   }
+                               }
+                           
+                               public class Program
+                               {
+                                   public static void Main()
+                                   {
+                                       var composition = new OtherComposition();
+                                       var service = composition.MyService;
+                                   }
+                               }
+                           }
+                           """.RunAsync();
+
+        // Then
+        result.Success.ShouldBeTrue(result);
+        result.StdOut.ShouldBe(["Initialize 1 Abc"], result);
+    }
 }