#88 Support for contextual/scoped dependency overrides 2

Author: NikolayPianikov

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

@@ -41,7 +41,11 @@ public void Build(BuildContext ctx, in DpConstruct construct)
                 break;
 
             case MdConstructKind.Accumulator:
-            case MdConstructKind.Override:
+                break;
+
+            case MdConstructKind.Override
+                when construct.Source.State is MdOverride @override:
+                BuildOverride(ctx, @override);
                 break;
 
             case MdConstructKind.None:
@@ -137,4 +141,10 @@ private static void BuildExplicitDefaultValue(BuildContext ctx, in DpConstruct e
         var variable = ctx.Variable;
         ctx.Code.AppendLine($"{ctx.BuildTools.GetDeclaration(variable)}{variable.VariableName} = {explicitDefault.Source.ExplicitDefaultValue.ValueToString()};");
     }
+
+    private static void BuildOverride(BuildContext ctx, in MdOverride @override)
+    {
+        var variable = ctx.Variable;
+        ctx.Code.AppendLine($"{ctx.BuildTools.GetDeclaration(variable)}{variable.VariableName} = {@override.ValueExpression.ValueToString()};");
+    }
 }

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

@@ -153,7 +153,7 @@ public void Build(BuildContext ctx, in DpFactory factory)
 
         // Rewrites syntax tree
         var finishLabel = $"{variable.VariableDeclarationName}Finish";
-        var factoryExpression = (LambdaExpressionSyntax)factory.Source.LocalVariableRenamingRewriter.Rewrite(ctx.DependencyGraph.Source.SemanticModel, ctx.DependencyGraph.Source.Hints.IsFormatCodeEnabled, false, originalLambda);
+        var factoryExpression = (LambdaExpressionSyntax)factory.Source.LocalVariableRenamingRewriter.Clone().Rewrite(ctx.DependencyGraph.Source.SemanticModel, ctx.DependencyGraph.Source.Hints.IsFormatCodeEnabled, false, originalLambda);
         var injections = new List<FactoryRewriter.Injection>();
         var inits = new List<FactoryRewriter.Initializer>();
         var factoryRewriter = new FactoryRewriter(arguments, compilations, factory, variable, finishLabel, injections, inits, triviaTools, symbolNames);

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

@@ -3,4 +3,6 @@
 interface ILocalVariableRenamingRewriter
 {
     SyntaxNode Rewrite(SemanticModel semanticModel, bool formatCode, bool isPartial, SyntaxNode lambda);
+
+    ILocalVariableRenamingRewriter Clone();
 }

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

@@ -7,7 +7,7 @@ sealed class LocalVariableRenamingRewriter(
     IVariableNameProvider variableNameProvider)
     : CSharpSyntaxRewriter, ILocalVariableRenamingRewriter
 {
-    private readonly Dictionary<string, string> _names = [];
+    private Dictionary<string, string> Names { get; init; } = [];
     private bool _formatCode;
     private bool _isPartial;
     private SemanticModel? _semanticModel;
@@ -20,6 +20,14 @@ public SyntaxNode Rewrite(SemanticModel semanticModel, bool formatCode, bool isP
         return Visit(lambda);
     }
 
+    public ILocalVariableRenamingRewriter Clone()
+    {
+        return new LocalVariableRenamingRewriter(triviaTools, variableNameProvider)
+        {
+            Names = new Dictionary<string, string>(Names)
+        };
+    }
+
     public override SyntaxNode? VisitVariableDeclarator(VariableDeclaratorSyntax node) =>
         base.VisitVariableDeclarator(node.WithIdentifier(SyntaxFactory.Identifier(GetUniqueName(node.Identifier.Text))));
 
@@ -31,7 +39,7 @@ public SyntaxNode Rewrite(SemanticModel semanticModel, bool formatCode, bool isP
 
     public override SyntaxToken VisitToken(SyntaxToken token)
     {
-        if (_names.TryGetValue(token.Text, out var newName)
+        if (Names.TryGetValue(token.Text, out var newName)
             && token.IsKind(SyntaxKind.IdentifierToken)
             && token.Parent is {} parent
             && (_semanticModel?.SyntaxTree != parent.SyntaxTree || _semanticModel.GetSymbolInfo(parent).Symbol is ILocalSymbol))
@@ -44,10 +52,10 @@ public override SyntaxToken VisitToken(SyntaxToken token)
 
     private string GetUniqueName(string baseName)
     {
-        if (!_names.TryGetValue(baseName, out var newName))
+        if (!Names.TryGetValue(baseName, out var newName))
         {
             newName = variableNameProvider.GetLocalUniqueVariableName(baseName);
-            _names.Add(baseName, newName);
+            Names.Add(baseName, newName);
         }
 
         return newName;

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

@@ -213,14 +213,6 @@ private Variable GetVariable(
             };
         }
 
-        if (node.Construct is { Source: { Kind: MdConstructKind.Override, State: MdOverride @override } })
-        {
-            return new Variable(variableNameProvider, setup, parentBlock, node.Binding.Id, node, injection, new List<IStatement>(), new VariableInfo(), nodeInfo.IsLazy(node), false)
-            {
-                VariableCode = @override.ValueExpression.ToString()
-            };
-        }
-
         if (node.Arg is null)
         {
             // ReSharper disable once SwitchStatementMissingSomeEnumCasesNoDefault

tests/Pure.DI.IntegrationTests/OverrideTests.cs

@@ -323,4 +323,94 @@ public static void Main()
         result.Success.ShouldBeTrue(result);
         result.StdOut.ShouldBe(["Sample.LoggerA", "Sample.LoggerA", "Sample.LoggerB", "Sample.LoggerB"], result);
     }
+
+    [Fact]
+    public async Task ShouldSupportOverrideWhenFuncWithArg()
+    {
+        // Given
+
+        // When
+        var result = await """
+                           using System;
+                           using Pure.DI;
+
+                           namespace Sample
+                           {
+                               interface ILogger {}
+                               
+                               class Logger: ILogger
+                               {
+                               }
+                               
+                               interface IDependency 
+                               {
+                                    ILogger Logger { get; }
+                               }
+                           
+                               class Dependency: IDependency
+                               {
+                                   public Dependency(ILogger logger, string name)
+                                   {
+                                        Logger = logger;
+                                        Console.WriteLine(name);
+                                   }
+                                   
+                                   public ILogger Logger { get; set; }
+                               }
+                           
+                               interface IService
+                               {
+                                   IDependency Dep { get; }
+                                   
+                                   ILogger Logger { get; }
+                               }
+                           
+                               class Service: IService 
+                               {
+                                   public Service(Func<string, IDependency> dep, ILogger logger)
+                                   {
+                                        Dep = dep("Abc");
+                                        Logger = logger;
+                                   }
+                           
+                                   public IDependency Dep { get; set; }
+                                   
+                                   public ILogger Logger { get; set; }
+                               }
+                           
+                               static class Setup
+                               {
+                                   private static void SetupComposition()
+                                   {
+                                       DI.Setup("Composition")
+                                           .Bind().To<Logger>()
+                                           .Bind().To<Func<string, IDependency>>(ctx =>
+                                           { 
+                                                return new Func<string, IDependency>(name => 
+                                                {
+                                                    ctx.Override(name);
+                                                    ctx.Inject(out Dependency dep);
+                                                    return dep;
+                                                });
+                                           })
+                                           .Bind().To<Service>()
+                                           .Root<IService>("Root");
+                                   }
+                               }
+                           
+                               public class Program
+                               {
+                                   public static void Main()
+                                   {
+                                       var composition = new Composition();
+                                       var root = composition.Root;
+                                   }
+                               }
+                           }
+                           """.RunAsync();
+
+        // Then
+        result.Success.ShouldBeTrue(result);
+        result.StdOut.ShouldBe(["Abc"], result);
+    }
 }