Implemented SetupContextKind.Reference to allow passing setup context by reference.

Author: NikolayPianikov

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

@@ -1504,7 +1504,12 @@ internal enum SetupContextKind
         /// <summary>
         /// Copies referenced instance members into the dependent composition.
         /// </summary>
-        Members
+        Members,
+
+        /// <summary>
+        /// Passes the setup context by reference and rewrites instance member access through it.
+        /// </summary>
+        Reference
     }
 
     /// <summary>

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

@@ -1509,7 +1509,12 @@ namespace Pure.DI
         /// <summary>
         /// Copies referenced instance members into the dependent composition.
         /// </summary>
-        Members
+        Members,
+
+        /// <summary>
+        /// Passes the setup context by reference and rewrites instance member access through it.
+        /// </summary>
+        Reference
     }
 
     /// <summary>

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

@@ -137,7 +137,7 @@ IReadOnlyCollection<string> CreateRootDescriptions(Root root) =>
                 var args = composition.ClassArgs
                     .Where(i => i.Node.Arg?.Source.Kind == ArgKind.Composition)
                     .Select(arg => arg.Name)
-                    .Concat(composition.SetupContextArgs.Where(arg => arg.Kind == SetupContextKind.Argument).Select(arg => arg.Name));
+                    .Concat(composition.SetupContextArgs.Where(arg => arg.Kind is SetupContextKind.Argument or SetupContextKind.Reference).Select(arg => arg.Name));
                 code.AppendLine($"/// {(composition.TotalDisposablesCount == 0 ? "" : "using ")}var composition = new {composition.Source.Source.Name.ClassName}({string.Join(", ", args)});");
                 code.AppendLine($"/// var instance = composition.{formatter.Format(root)};");
                 code.AppendLine("/// </code>");

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

@@ -17,11 +17,11 @@ public bool IsEnabled(CompositionCode composition, ConstructorKind kind) =>
         };
 
     private static bool HasSetupContextParameters(CompositionCode composition) =>
-        composition.SetupContextArgs.Any(arg => arg.Kind == SetupContextKind.Argument);
+        composition.SetupContextArgs.Any(arg => arg.Kind is SetupContextKind.Argument or SetupContextKind.Reference);
 
     private static bool HasSetupContextArgs(DependencyGraph graph) =>
         graph.Source.Bindings.Any(binding =>
-            binding.Arg is { IsSetupContext: true, SetupContextKind: SetupContextKind.Argument });
+            binding.Arg is { IsSetupContext: true, SetupContextKind: SetupContextKind.Argument or SetupContextKind.Reference });
 
     private bool IsEnabledInternal(DependencyGraph graph) => (
         from entry in graph.Graph.Entries

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

@@ -38,7 +38,7 @@ public void AddComments(CompositionCode composition, Unit unit)
             }
         }
 
-        foreach (var arg in composition.SetupContextArgs.Where(i => i.Kind == SetupContextKind.Argument))
+        foreach (var arg in composition.SetupContextArgs.Where(i => i.Kind is SetupContextKind.Argument or SetupContextKind.Reference))
         {
             code.AppendLine($"/// <param name=\"{arg.Name}\">The setup context of type {formatter.FormatRef(arg.Type)}.</param>");
         }

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

@@ -35,6 +35,7 @@ public CompositionCode Build(CompositionCode composition)
             switch (arg.Kind)
             {
                 case SetupContextKind.Argument:
+                case SetupContextKind.Reference:
                     var typeName = typeResolver.Resolve(composition.Source.Source, arg.Type);
                     code.AppendLine($"[{Names.NonSerializedAttributeTypeName}] private readonly {typeName} {arg.Name};");
                     membersCounter++;

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

@@ -21,7 +21,7 @@ public CompositionCode Build(CompositionCode composition)
 
         var code = composition.Code;
         var membersCounter = composition.MembersCount;
-        var setupContextArgs = composition.SetupContextArgs.Where(arg => arg.Kind == SetupContextKind.Argument).ToArray();
+        var setupContextArgs = composition.SetupContextArgs.Where(arg => arg.Kind is SetupContextKind.Argument or SetupContextKind.Reference).ToArray();
         if (composition.ClassArgs.Length == 0 && setupContextArgs.Length == 0)
         {
             return composition;

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

@@ -48,7 +48,7 @@ public void AddComments(CompositionCode composition, Root root)
             var args = composition.ClassArgs
                 .Where(i => i.Node.Arg?.Source.Kind == ArgKind.Composition)
                 .Select(arg => arg.Name)
-                .Concat(composition.SetupContextArgs.Where(arg => arg.Kind == SetupContextKind.Argument).Select(arg => arg.Name));
+                .Concat(composition.SetupContextArgs.Where(arg => arg.Kind is SetupContextKind.Argument or SetupContextKind.Reference).Select(arg => arg.Name));
             code.AppendLine($"/// {(composition.TotalDisposablesCount == 0 ? "" : "using ")}var composition = new {composition.Source.Source.Name.ClassName}({string.Join(", ", args)});");
             code.AppendLine($"/// var instance = composition.{formatter.Format(root)};");
             code.AppendLine("/// </code>");

tests/Pure.DI.IntegrationTests/SetupContextTests.cs

@@ -1566,4 +1566,95 @@ public static void Main()
         result.Warnings.Count.ShouldBe(0, result);
         result.StdOut.ShouldBe(["41", "True", "41", "False", "True", "True"], result);
     }
+
+    [Fact]
+    public async Task ShouldSupportSetupContextReferenceWhenCreatingScope()
+    {
+        // Given
+
+        // When
+        var result = await """
+                           using System;
+                           using Pure.DI;
+
+                           namespace UnityEngine
+                           {
+                               // Lightweight test double to avoid Unity dependency
+                               public class MonoBehaviour {}
+                           }
+
+                           namespace Sample
+                           {
+                               internal partial class BaseComposition
+                               {
+                                   internal int SettingsValue { get; set; }
+
+                                   private void Setup()
+                                   {
+                                       DI.Setup(nameof(BaseComposition), CompositionKind.Internal)
+                                           .Bind<int>().To(_ => SettingsValue);
+                                   }
+                               }
+
+                               interface IService
+                               {
+                                   int Value { get; }
+                               }
+
+                               sealed class Service : IService
+                               {
+                                   public Service(int value)
+                                   {
+                                       Value = value;
+                                   }
+
+                                   public int Value { get; }
+                               }
+
+                               internal partial class Composition : UnityEngine.MonoBehaviour
+                               {
+                                   private void Setup()
+                                   {
+                                       DI.Setup(nameof(Composition))
+                                           .DependsOn(nameof(BaseComposition), SetupContextKind.Reference, "baseContext")
+                                           .Bind<IService>().As(Lifetime.Scoped).To<Service>()
+                                           .Root<IService>("Service");
+                                   }
+
+                                   public Composition CreateScope() => new(this);
+                               }
+
+                               public class Program
+                               {
+                                   public static void Main()
+                                   {
+                                       var baseContext = new BaseComposition
+                                       {
+                                           SettingsValue = 41
+                                       };
+
+                                       var composition = new Composition(baseContext);
+
+                                       var scope1 = composition.CreateScope();
+                                       var service11 = scope1.Service;
+                                       var service12 = scope1.Service;
+                                       Console.WriteLine(service11.Value);
+                                       Console.WriteLine(service11 == service12);
+
+                                       baseContext.SettingsValue = 73;
+                                       var scope2 = composition.CreateScope();
+                                       var service2 = scope2.Service;
+                                       Console.WriteLine(service2.Value);
+                                       Console.WriteLine(service11 == service2);
+                                   }
+                               }
+                           }
+                           """.RunAsync(new Options(LanguageVersion: LanguageVersion.CSharp9));
+
+        // Then
+        result.Success.ShouldBeTrue(result);
+        result.Errors.Count.ShouldBe(0, result);
+        result.Warnings.Count.ShouldBe(0, result);
+        result.StdOut.ShouldBe(["41", "True", "73", "False"], result);
+    }
 }