#88 Support for contextual/scoped dependency overrides

NikolayPianikov · NikolayPianikov · commit 4b4e05139e50 · 2025-04-04T16:42:23.000+03:00
diff --git a/src/Pure.DI.Core/Components/Api.g.cs b/src/Pure.DI.Core/Components/Api.g.cs
@@ -2994,8 +2994,6 @@ internal interface IContext
         ///         var service = new Service();
         ///         // Initialize an instance with all necessary dependencies
         ///         ctx.BuildUp(service);
-        ///
-        /// 
         ///         return service;
         ///     })
         /// </code>
@@ -3006,7 +3004,7 @@ internal interface IContext
         /// <seealso cref="IBinding.To{T}(System.Func{Pure.DI.IContext,T})"/>
         void BuildUp<T>(T value);
 
-        void Override<T>(T value, object tag = null);
+        void Override<T>(T value, params object[] tags);
     }
     
     /// <summary>
diff --git a/src/Pure.DI.Core/Core/ApiInvocationProcessor.cs b/src/Pure.DI.Core/Core/ApiInvocationProcessor.cs
@@ -23,6 +23,7 @@ sealed class ApiInvocationProcessor(
     : IApiInvocationProcessor
 {
     private static readonly char[] TypeNamePartsSeparators = ['.'];
+    private static object NullTag = new object();
 
     public void ProcessInvocation(
         IMetadataVisitor metadataVisitor,
@@ -817,12 +818,12 @@ private MdOverride CreateOverride(
         ref bool hasContextTag)
     {
         var invocation = @override.Expression;
-        if (invocation.ArgumentList.Arguments is not { Count: 1 or 2 })
+        if (invocation.ArgumentList.Arguments.Count == 0)
         {
             return default;
         }
 
-        var args = arguments.GetArgs(invocation.ArgumentList, "value", "tag");
+        var args = arguments.GetArgs(invocation.ArgumentList, "value", "tags");
         if (args[0] is not {} valueArg)
         {
             return default;
@@ -834,19 +835,22 @@ private MdOverride CreateOverride(
             return default;
         }
 
-        var tag = args[1]?.Expression;
-        var hasCtx = HasContextTag(tag, contextParameter);
-        hasContextTag |= hasCtx;
-        var tagValue = hasCtx ? MdTag.ContextTag : tag is null ? null : semantic.GetConstantValue<object>(semanticModel, tag);
-        var resolverTag = new MdTag(0, tagValue);
+        var tagArguments = invocation.ArgumentList.Arguments.Skip(1).ToList();
+        var hasCtx = tagArguments.Aggregate(false, (current, tag) => current | HasContextTag(tag.Expression, contextParameter));
+        var tags = BuildTags(semanticModel, tagArguments)
+            .AsEnumerable()
+            .Select(tag => tag with { Value = tag.Value ?? (hasCtx ? MdTag.ContextTag : null) })
+            .DefaultIfEmpty(new MdTag(0, hasCtx ? MdTag.ContextTag : null))
+            .ToImmutableArray();
+
         var valueExpression = (ExpressionSyntax)localVariableRenamingRewriter.Rewrite(semanticModel, false, true, valueArg.Expression);
         return new MdOverride(
             semanticModel,
             invocation,
-            overrideIdProvider.GetId(argType, tagValue),
+            overrideIdProvider.GetId(argType, tags.Select(tag => tag.Value ?? NullTag).ToImmutableHashSet()),
             @override.Position,
             argType,
-            resolverTag,
+            tags,
             valueExpression);
     }
 
diff --git a/src/Pure.DI.Core/Core/ArgDependencyNodeBuilder.cs b/src/Pure.DI.Core/Core/ArgDependencyNodeBuilder.cs
@@ -13,7 +13,7 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)
                 continue;
             }
 
-            yield return new DependencyNode(0, binding, Arg: new DpArg(arg, binding));
+            yield return new DependencyNode(0, binding, ctx.TypeConstructor, Arg: new DpArg(arg, binding));
         }
     }
 }
diff --git a/src/Pure.DI.Core/Core/Code/CompositionBuilder.cs b/src/Pure.DI.Core/Core/Code/CompositionBuilder.cs
@@ -41,7 +41,9 @@ public CompositionCode Build(DependencyGraph graph)
             foreach (var perResolveVar in map.GetPerResolves())
             {
                 ctx.Code.AppendLine($"var {perResolveVar.VariableName} = default({typeResolver.Resolve(graph.Source, perResolveVar.InstanceType)});");
-                if (perResolveVar.Info.RefCount > 0 && perResolveVar.InstanceType.IsValueType)
+                if (perResolveVar.Info.RefCount > 0
+                    && perResolveVar.InstanceType.IsValueType
+                    && perResolveVar.Node.Construct is not { Source.Kind: MdConstructKind.Override })
                 {
                     ctx.Code.AppendLine($"var {perResolveVar.VariableName}Created = false;");
                 }
diff --git a/src/Pure.DI.Core/Core/Code/CompositionClassBuilder.cs b/src/Pure.DI.Core/Core/Code/CompositionClassBuilder.cs
@@ -22,7 +22,6 @@ public CompositionCode Build(CompositionCode composition)
         if (composition.Compilation.Options.NullableContextOptions != NullableContextOptions.Disable)
         {
             code.AppendLine("#nullable enable annotations");
-            code.AppendLine("#pragma warning disable CS0219");
         }
 
         code.AppendLine();
diff --git a/src/Pure.DI.Core/Core/Code/IVariablesMap.cs b/src/Pure.DI.Core/Core/Code/IVariablesMap.cs
@@ -8,6 +8,5 @@ interface IVariablesMap : IDictionary<MdBinding, Variable>
 
     IEnumerable<Variable> GetSingletons();
 
-
     IEnumerable<Variable> GetPerResolves();
 }
diff --git a/src/Pure.DI.Core/Core/ConstructDependencyNodeBuilder.cs b/src/Pure.DI.Core/Core/ConstructDependencyNodeBuilder.cs
@@ -31,7 +31,7 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)
                         tag));
             }
 
-            yield return new DependencyNode(0, binding, Construct: new DpConstruct(construct, binding, injections.ToImmutableArray()));
+            yield return new DependencyNode(0, binding, ctx.TypeConstructor, Construct: new DpConstruct(construct, binding, injections.ToImmutableArray()));
         }
     }
 }
diff --git a/src/Pure.DI.Core/Core/DependencyGraphBuilder.cs b/src/Pure.DI.Core/Core/DependencyGraphBuilder.cs
@@ -125,7 +125,7 @@ public IEnumerable<DependencyNode> TryBuild(
                         when namedTypeSymbol.IsGenericType || marker.IsMarkerBased(setup, namedTypeSymbol):
                     {
                         var isDone = false;
-                        foreach (var item in map)
+                        foreach (var item in map.OrderByDescending(i => i.Value.Binding.Id))
                         {
                             if (item.Key.Type is not INamedTypeSymbol nextNamedTypeSymbol)
                             {
@@ -349,7 +349,7 @@ public IEnumerable<DependencyNode> TryBuild(
                 var injection = injectionInfo.Injection;
                 var dependency = map.TryGetValue(injection, out var sourceNode)
                     ? new Dependency(true, sourceNode, injection, node.Node)
-                    : new Dependency(false, new DependencyNode(0, node.Node.Binding), injection, node.Node);
+                    : new Dependency(false, new DependencyNode(0, node.Node.Binding, node.Node.TypeConstructor), injection, node.Node);
 
                 edges.Add(dependency);
             }
@@ -363,8 +363,7 @@ public IEnumerable<DependencyNode> TryBuild(
         var overrideMap = new Dictionary<Injection, DependencyNode>();
         foreach (var rootNode in from node in graph.Vertices where node.Root is not null select node)
         {
-            var typeConstructor = typeConstructorFactory();
-            Override(processedNodes, [], overrideMap, setup, graph, rootNode, ref maxId, typeConstructor, overridingEntries);
+            Override(processedNodes, [], overrideMap, setup, graph, rootNode, ref maxId, overridingEntries);
         }
 
         if (overridingEntries.Count > 0)
@@ -416,7 +415,6 @@ private void Override(HashSet<DependencyNode> processedNodes,
         Graph<DependencyNode, Dependency> graph,
         DependencyNode targetNode,
         ref int maxId,
-        ITypeConstructor typeConstructor,
         List<GraphEntry<DependencyNode, Dependency>> overridingEntries)
     {
         if (!processedNodes.Add(targetNode))
@@ -429,29 +427,40 @@ private void Override(HashSet<DependencyNode> processedNodes,
             return;
         }
 
+        var typeConstructor = targetNode.TypeConstructor;
         if (targetNode.Factory is {} factory)
         {
             foreach (var resolver in factory.Resolvers)
             {
-                //typeConstructor.Construct(setup, )
                 foreach (var @override in resolver.Overrides)
                 {
-                    overriddenInjections.Add(@override.Injection);
-                    if (!overrideMap.TryGetValue(@override.Injection, out _))
+                    if (@override.Injections.IsDefaultOrEmpty)
                     {
-                        var overrideBinding = CreateConstructBinding(
-                            setup,
-                            targetNode,
-                            @override.Injection,
-                            @override.Source.ContractType,
-                            Lifetime.PerResolve,
-                            ++maxId,
-                            MdConstructKind.Override,
-                            state: @override);
+                        continue;
+                    }
 
-                        foreach (var sourceNode in CreateNodes(setup, typeConstructorFactory(), overrideBinding))
+                    MdBinding? overrideBinding = null;
+                    foreach (var overrideInjection in @override.Injections)
+                    {
+                        var injection = overrideInjection with {Type = typeConstructor.Construct(setup, overrideInjection.Type)};
+                        var contractType = typeConstructor.Construct(setup, @override.Source.ContractType);
+                        overriddenInjections.Add(injection);
+                        if (!overrideMap.TryGetValue(injection, out _))
                         {
-                            overrideMap[@override.Injection] = sourceNode;
+                            overrideBinding ??= CreateConstructBinding(
+                                setup,
+                                targetNode,
+                                injection,
+                                contractType,
+                                Lifetime.PerResolve,
+                                ++maxId,
+                                MdConstructKind.Override,
+                                state: @override);
+
+                            foreach (var sourceNode in CreateNodes(setup, typeConstructor, overrideBinding))
+                            {
+                                overrideMap[injection] = sourceNode;
+                            }
                         }
                     }
                 }
@@ -464,7 +473,7 @@ private void Override(HashSet<DependencyNode> processedNodes,
         {
             if (!overriddenInjections.Contains(dependency.Injection) || !overrideMap.TryGetValue(dependency.Injection, out var overridingSourceNode))
             {
-                Override(processedNodes, overriddenInjections, overrideMap, setup, graph, dependency.Source, ref maxId, typeConstructor, overridingEntries);
+                Override(processedNodes, overriddenInjections, overrideMap, setup, graph, dependency.Source, ref maxId, overridingEntries);
                 newDependencies.Add(dependency);
                 continue;
             }
diff --git a/src/Pure.DI.Core/Core/FactoryApiWalker.cs b/src/Pure.DI.Core/Core/FactoryApiWalker.cs
@@ -36,7 +36,7 @@ when invocation.ArgumentList.Arguments.Count is 1 or 2
                         break;
 
                     case nameof(IContext.Override)
-                        when invocation.ArgumentList.Arguments.Count is 1 or 2
+                        when invocation.ArgumentList.Arguments.Count > 0
                              && memberAccess is { Expression: IdentifierNameSyntax contextIdentifierName }
                              && contextIdentifierName.IsKind(SyntaxKind.IdentifierName):
                         _overrides.Add(new OverrideMeta(_position++, invocation));
@@ -63,7 +63,7 @@ when invocation.ArgumentList.Arguments.Count is 1 or 2
                         break;
 
                     case nameof(IContext.Override)
-                        when invocation.ArgumentList.Arguments.Count is 1 or 2
+                        when invocation.ArgumentList.Arguments.Count > 0
                              && memberAccess is { Expression: IdentifierNameSyntax contextIdentifierName }
                              && contextIdentifierName.IsKind(SyntaxKind.IdentifierName):
                         _overrides.Add(new OverrideMeta(_position++, invocation));
diff --git a/src/Pure.DI.Core/Core/FactoryDependencyNodeBuilder.cs b/src/Pure.DI.Core/Core/FactoryDependencyNodeBuilder.cs
@@ -39,14 +39,14 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)
             }
 
             var dpFactory = new DpFactory(factory, binding, resolvers.ToImmutableArray(), initializers.ToImmutableArray());
-            yield return new DependencyNode(0, binding, Factory: dpFactory);
+            yield return new DependencyNode(0, binding, ctx.TypeConstructor, Factory: dpFactory);
         }
     }
 
     private static ImmutableArray<DpOverride> CreateOverrides(in ImmutableArray<MdOverride> overrides) =>
         overrides.IsDefault
             ? ImmutableArray<DpOverride>.Empty
             : overrides.AsEnumerable()
-                .Select(i => new DpOverride(i, new Injection(InjectionKind.Override, i.ContractType, i.Tag?.Value)))
+                .Select(i => new DpOverride(i, i.Tags.Select(tag => new Injection(InjectionKind.Override, i.ContractType, tag.Value)).ToImmutableArray()))
                 .ToImmutableArray();
 }
diff --git a/src/Pure.DI.Core/Core/IOverrideIdProvider.cs b/src/Pure.DI.Core/Core/IOverrideIdProvider.cs
@@ -2,5 +2,5 @@
 
 interface IOverrideIdProvider
 {
-    int GetId(ITypeSymbol type, object? tag);
+    int GetId(ITypeSymbol type, ISet<object> tags);
 }
diff --git a/src/Pure.DI.Core/Core/ImplementationDependencyNodeBuilder.cs b/src/Pure.DI.Core/Core/ImplementationDependencyNodeBuilder.cs
@@ -83,27 +83,27 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)
 
             if (implementationsWithOrdinal.Count > 0)
             {
-                foreach (var node in CreateNodes(injectionsCounter, implementationsWithOrdinal.OrderBy(i => i.Constructor.Ordinal)))
+                foreach (var node in CreateNodes(ctx, injectionsCounter, implementationsWithOrdinal.OrderBy(i => i.Constructor.Ordinal)))
                 {
                     yield return node;
                 }
 
                 continue;
             }
 
-            foreach (var node in CreateNodes(injectionsCounter, implementations))
+            foreach (var node in CreateNodes(ctx, injectionsCounter, implementations))
             {
                 yield return node;
             }
         }
     }
 
-    private IEnumerable<DependencyNode> CreateNodes(IConstructorInjectionsCounterWalker walker, IEnumerable<DpImplementation> implementations) =>
+    private IEnumerable<DependencyNode> CreateNodes(DependencyNodeBuildContext ctx, IConstructorInjectionsCounterWalker walker, IEnumerable<DpImplementation> implementations) =>
         implementations
             .OrderByDescending(i => GetInjectionsCount(walker, i.Constructor))
             .ThenByDescending(i => i.Constructor.Method.DeclaredAccessibility)
             .SelectMany(implementationVariantsBuilder.Build)
-            .Select((implementation, variantId) => new DependencyNode(variantId, implementation.Binding, Implementation: implementation));
+            .Select((implementation, variantId) => new DependencyNode(variantId, implementation.Binding, ctx.TypeConstructor, Implementation: implementation));
 
     private static int GetInjectionsCount(IConstructorInjectionsCounterWalker walker, in DpMethod constructor)
     {
diff --git a/src/Pure.DI.Core/Core/Models/DdOverride.cs b/src/Pure.DI.Core/Core/Models/DdOverride.cs
@@ -5,4 +5,4 @@ namespace Pure.DI.Core.Models;
 
 readonly record struct DpOverride(
     MdOverride Source,
-    Injection Injection);
+    ImmutableArray<Injection> Injections);
diff --git a/src/Pure.DI.Core/Core/Models/DependencyNode.cs b/src/Pure.DI.Core/Core/Models/DependencyNode.cs
@@ -3,6 +3,7 @@ namespace Pure.DI.Core.Models;
 record DependencyNode(
     int Variation,
     in MdBinding Binding,
+    ITypeConstructor TypeConstructor,
     ITypeSymbol Type,
     ICollection<Accumulator> Accumulators,
     in DpRoot? Root,
@@ -15,6 +16,7 @@ record DependencyNode(
     public DependencyNode(
         int Variation,
         in MdBinding binding,
+        ITypeConstructor typeConstructor,
         in DpRoot? Root = null,
         in DpImplementation? Implementation = null,
         in DpFactory? Factory = null,
@@ -23,6 +25,7 @@ public DependencyNode(
         : this(
             Variation,
             binding,
+            typeConstructor,
             Root?.Source.RootType ?? binding.Type,
             [],
             Root,
diff --git a/src/Pure.DI.Core/Core/Models/MdOverride.cs b/src/Pure.DI.Core/Core/Models/MdOverride.cs
@@ -9,5 +9,5 @@ readonly record struct MdOverride(
     int Id,
     int Position,
     ITypeSymbol ContractType,
-    MdTag? Tag,
+    in ImmutableArray<MdTag> Tags,
     ExpressionSyntax ValueExpression);
diff --git a/src/Pure.DI.Core/Core/OverrideIdProvider.cs b/src/Pure.DI.Core/Core/OverrideIdProvider.cs
@@ -5,8 +5,26 @@
 
 class OverrideIdProvider([Tag(Override)] IIdGenerator idGenerator) : IOverrideIdProvider
 {
-    private readonly ConcurrentDictionary<Injection, int> _ids = new();
+    private readonly ConcurrentDictionary<Key, int> _ids = new();
 
-    public int GetId(ITypeSymbol type, object? tag) =>
-        _ids.GetOrAdd(new Injection(InjectionKind.Override, type, tag), _ => idGenerator.Generate());
+    public int GetId(ITypeSymbol type, ISet<object> tags) =>
+        _ids.GetOrAdd(new Key(type, tags), _ => idGenerator.Generate());
+
+    private class Key(ITypeSymbol type, ISet<object> tags)
+    {
+        private readonly ITypeSymbol _type = type;
+        private readonly ISet<object> _tags = tags;
+
+        public override bool Equals(object? obj)
+        {
+            if (obj is null) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != GetType()) return false;
+            var other = (Key)obj;
+            return SymbolEqualityComparer.Default.Equals(_type, other._type) && _tags.Intersect(other._tags).Any();
+        }
+
+        public override int GetHashCode() =>
+            SymbolEqualityComparer.Default.GetHashCode(_type);
+    }
 }
diff --git a/src/Pure.DI.Core/Core/RootDependencyNodeBuilder.cs b/src/Pure.DI.Core/Core/RootDependencyNodeBuilder.cs
@@ -21,6 +21,7 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)
             yield return new DependencyNode(
                 0,
                 rootBinding,
+                ctx.TypeConstructor,
                 new DpRoot(
                     root,
                     rootBinding,
diff --git a/src/Pure.DI.Core/Features/Default.g.cs b/src/Pure.DI.Core/Features/Default.g.cs
diff --git a/tests/Pure.DI.IntegrationTests/LazyTests.cs b/tests/Pure.DI.IntegrationTests/LazyTests.cs
diff --git a/tests/Pure.DI.IntegrationTests/OverrideTests.cs b/tests/Pure.DI.IntegrationTests/OverrideTests.cs
diff --git a/tests/Pure.DI.UsageTests/BaseClassLibrary/FuncWithArgumentsScenario.cs b/tests/Pure.DI.UsageTests/BaseClassLibrary/FuncWithArgumentsScenario.cs
diff --git a/tests/Pure.DI.UsageTests/Basics/OverridesScenario.cs b/tests/Pure.DI.UsageTests/Basics/OverridesScenario.cs

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)`
`13`	`13`	`continue;`
`14`	`14`	`}`
`15`	`15`
`16`		`- yield return new DependencyNode(0, binding, Arg: new DpArg(arg, binding));`
	`16`	`+ yield return new DependencyNode(0, binding, ctx.TypeConstructor, Arg: new DpArg(arg, binding));`
`17`	`17`	`}`
`18`	`18`	`}`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,9 @@ public CompositionCode Build(DependencyGraph graph)`
`41`	`41`	`foreach (var perResolveVar in map.GetPerResolves())`
`42`	`42`	`{`
`43`	`43`	`ctx.Code.AppendLine($"var {perResolveVar.VariableName} = default({typeResolver.Resolve(graph.Source, perResolveVar.InstanceType)});");`
`44`		`- if (perResolveVar.Info.RefCount > 0 && perResolveVar.InstanceType.IsValueType)`
	`44`	`+ if (perResolveVar.Info.RefCount > 0`
	`45`	`+ && perResolveVar.InstanceType.IsValueType`
	`46`	`+ && perResolveVar.Node.Construct is not { Source.Kind: MdConstructKind.Override })`
`45`	`47`	`{`
`46`	`48`	`ctx.Code.AppendLine($"var {perResolveVar.VariableName}Created = false;");`
`47`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@ public CompositionCode Build(CompositionCode composition)`
`22`	`22`	`if (composition.Compilation.Options.NullableContextOptions != NullableContextOptions.Disable)`
`23`	`23`	`{`
`24`	`24`	`code.AppendLine("#nullable enable annotations");`
`25`		`- code.AppendLine("#pragma warning disable CS0219");`
`26`	`25`	`}`
`27`	`26`
`28`	`27`	`code.AppendLine();`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,5 @@ interface IVariablesMap : IDictionary<MdBinding, Variable>`
`8`	`8`
`9`	`9`	`IEnumerable<Variable> GetSingletons();`
`10`	`10`
`11`		`-`
`12`	`11`	`IEnumerable<Variable> GetPerResolves();`
`13`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)`
`31`	`31`	`tag));`
`32`	`32`	`}`
`33`	`33`
`34`		`- yield return new DependencyNode(0, binding, Construct: new DpConstruct(construct, binding, injections.ToImmutableArray()));`
	`34`	`+ yield return new DependencyNode(0, binding, ctx.TypeConstructor, Construct: new DpConstruct(construct, binding, injections.ToImmutableArray()));`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ public IEnumerable<DependencyNode> TryBuild(`
`125`	`125`	`when namedTypeSymbol.IsGenericType \|\| marker.IsMarkerBased(setup, namedTypeSymbol):`
`126`	`126`	`{`
`127`	`127`	`var isDone = false;`
`128`		`- foreach (var item in map)`
	`128`	`+ foreach (var item in map.OrderByDescending(i => i.Value.Binding.Id))`
`129`	`129`	`{`
`130`	`130`	`if (item.Key.Type is not INamedTypeSymbol nextNamedTypeSymbol)`
`131`	`131`	`{`
`@@ -349,7 +349,7 @@ public IEnumerable<DependencyNode> TryBuild(`
`349`	`349`	`var injection = injectionInfo.Injection;`
`350`	`350`	`var dependency = map.TryGetValue(injection, out var sourceNode)`
`351`	`351`	`? new Dependency(true, sourceNode, injection, node.Node)`
`352`		`- : new Dependency(false, new DependencyNode(0, node.Node.Binding), injection, node.Node);`
	`352`	`+ : new Dependency(false, new DependencyNode(0, node.Node.Binding, node.Node.TypeConstructor), injection, node.Node);`
`353`	`353`
`354`	`354`	`edges.Add(dependency);`
`355`	`355`	`}`
`@@ -363,8 +363,7 @@ public IEnumerable<DependencyNode> TryBuild(`
`363`	`363`	`var overrideMap = new Dictionary<Injection, DependencyNode>();`
`364`	`364`	`foreach (var rootNode in from node in graph.Vertices where node.Root is not null select node)`
`365`	`365`	`{`
`366`		`- var typeConstructor = typeConstructorFactory();`
`367`		`- Override(processedNodes, [], overrideMap, setup, graph, rootNode, ref maxId, typeConstructor, overridingEntries);`
	`366`	`+ Override(processedNodes, [], overrideMap, setup, graph, rootNode, ref maxId, overridingEntries);`
`368`	`367`	`}`
`369`	`368`
`370`	`369`	`if (overridingEntries.Count > 0)`
`@@ -416,7 +415,6 @@ private void Override(HashSet<DependencyNode> processedNodes,`
`416`	`415`	`Graph<DependencyNode, Dependency> graph,`
`417`	`416`	`DependencyNode targetNode,`
`418`	`417`	`ref int maxId,`
`419`		`- ITypeConstructor typeConstructor,`
`420`	`418`	`List<GraphEntry<DependencyNode, Dependency>> overridingEntries)`
`421`	`419`	`{`
`422`	`420`	`if (!processedNodes.Add(targetNode))`
`@@ -429,29 +427,40 @@ private void Override(HashSet<DependencyNode> processedNodes,`
`429`	`427`	`return;`
`430`	`428`	`}`
`431`	`429`
	`430`	`+ var typeConstructor = targetNode.TypeConstructor;`
`432`	`431`	`if (targetNode.Factory is {} factory)`
`433`	`432`	`{`
`434`	`433`	`foreach (var resolver in factory.Resolvers)`
`435`	`434`	`{`
`436`		`- //typeConstructor.Construct(setup, )`
`437`	`435`	`foreach (var @override in resolver.Overrides)`
`438`	`436`	`{`
`439`		`- overriddenInjections.Add(@override.Injection);`
`440`		`- if (!overrideMap.TryGetValue(@override.Injection, out _))`
	`437`	`+ if (@override.Injections.IsDefaultOrEmpty)`
`441`	`438`	`{`
`442`		`- var overrideBinding = CreateConstructBinding(`
`443`		`- setup,`
`444`		`- targetNode,`
`445`		`- @override.Injection,`
`446`		`- @override.Source.ContractType,`
`447`		`- Lifetime.PerResolve,`
`448`		`- ++maxId,`
`449`		`- MdConstructKind.Override,`
`450`		`- state: @override);`
	`439`	`+ continue;`
	`440`	`+ }`
`451`	`441`
`452`		`- foreach (var sourceNode in CreateNodes(setup, typeConstructorFactory(), overrideBinding))`
	`442`	`+ MdBinding? overrideBinding = null;`
	`443`	`+ foreach (var overrideInjection in @override.Injections)`
	`444`	`+ {`
	`445`	`+ var injection = overrideInjection with {Type = typeConstructor.Construct(setup, overrideInjection.Type)};`
	`446`	`+ var contractType = typeConstructor.Construct(setup, @override.Source.ContractType);`
	`447`	`+ overriddenInjections.Add(injection);`
	`448`	`+ if (!overrideMap.TryGetValue(injection, out _))`
`453`	`449`	`{`
`454`		`- overrideMap[@override.Injection] = sourceNode;`
	`450`	`+ overrideBinding ??= CreateConstructBinding(`
	`451`	`+ setup,`
	`452`	`+ targetNode,`
	`453`	`+ injection,`
	`454`	`+ contractType,`
	`455`	`+ Lifetime.PerResolve,`
	`456`	`+ ++maxId,`
	`457`	`+ MdConstructKind.Override,`
	`458`	`+ state: @override);`
	`459`	`+`
	`460`	`+ foreach (var sourceNode in CreateNodes(setup, typeConstructor, overrideBinding))`
	`461`	`+ {`
	`462`	`+ overrideMap[injection] = sourceNode;`
	`463`	`+ }`
`455`	`464`	`}`
`456`	`465`	`}`
`457`	`466`	`}`
`@@ -464,7 +473,7 @@ private void Override(HashSet<DependencyNode> processedNodes,`
`464`	`473`	`{`
`465`	`474`	`if (!overriddenInjections.Contains(dependency.Injection) \|\| !overrideMap.TryGetValue(dependency.Injection, out var overridingSourceNode))`
`466`	`475`	`{`
`467`		`- Override(processedNodes, overriddenInjections, overrideMap, setup, graph, dependency.Source, ref maxId, typeConstructor, overridingEntries);`
	`476`	`+ Override(processedNodes, overriddenInjections, overrideMap, setup, graph, dependency.Source, ref maxId, overridingEntries);`
`468`	`477`	`newDependencies.Add(dependency);`
`469`	`478`	`continue;`
`470`	`479`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,14 +39,14 @@ public IEnumerable<DependencyNode> Build(DependencyNodeBuildContext ctx)`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`var dpFactory = new DpFactory(factory, binding, resolvers.ToImmutableArray(), initializers.ToImmutableArray());`
`42`		`- yield return new DependencyNode(0, binding, Factory: dpFactory);`
	`42`	`+ yield return new DependencyNode(0, binding, ctx.TypeConstructor, Factory: dpFactory);`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`private static ImmutableArray<DpOverride> CreateOverrides(in ImmutableArray<MdOverride> overrides) =>`
`47`	`47`	`overrides.IsDefault`
`48`	`48`	`? ImmutableArray<DpOverride>.Empty`
`49`	`49`	`: overrides.AsEnumerable()`
`50`		`- .Select(i => new DpOverride(i, new Injection(InjectionKind.Override, i.ContractType, i.Tag?.Value)))`
	`50`	`+ .Select(i => new DpOverride(i, i.Tags.Select(tag => new Injection(InjectionKind.Override, i.ContractType, tag.Value)).ToImmutableArray()))`
`51`	`51`	`.ToImmutableArray();`
`52`	`52`	`}`