#136 Insufficient performance

NikolayPianikov · NikolayPianikov · commit 89ddc6946bea · 2026-03-10T19:52:33.000+03:00
diff --git a/src/Pure.DI.Core/Core/DependencyGraphBuilder.cs b/src/Pure.DI.Core/Core/DependencyGraphBuilder.cs
@@ -33,7 +33,6 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
         var setup = ctx.Setup;
         var nodes = ctx.Nodes;
         var accumulators = ctx.Accumulators;
-        var nodesCache = ctx.NodesCache;
         var nodesLength = nodes.Length;
         var map = new Dictionary<Injection, DependencyNode>(nodesLength);
         var contextMap = new Dictionary<Injection, DependencyNode>(nodesLength);
@@ -120,7 +119,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                         var contextTag = GetContextTag(injection, newNode);
                         var newInjection = injection with { Tag = contextTag ?? injection.Tag };
                         edges.Add(new Dependency(true, newNode, newInjection, targetNode, position));
-                        queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode));
+                        queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, newNode));
                     }
 
                     continue;
@@ -135,7 +134,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                 {
                     if (!marker.IsMarkerBased(setup, sourceNode!.Type))
                     {
-                        queue.Enqueue(CreateNewProcessingNode(nodesCache, injection.Tag, sourceNode));
+                        queue.Enqueue(CreateNewProcessingNode(injection.Tag, sourceNode));
                         continue;
                     }
                 }
@@ -156,7 +155,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                     {
                         var contextTag = GetContextTag(injection, newNode);
                         var newInjection = injection with { Tag = contextTag ?? injection.Tag };
-                        var newProcessingNode = CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode);
+                        var newProcessingNode = CreateNewProcessingNode(newInjection.Tag, newNode);
                         UpdateMap(newInjection, newNode);
                         queue.Enqueue(newProcessingNode);
                     }
@@ -207,7 +206,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                             if (genericNode is not null)
                             {
                                 UpdateMap(newInjection, genericNode);
-                                queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, genericNode));
+                                queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, genericNode));
                                 foreach (var contract in genericBinding.Contracts.Where(i => i.ContractType is not null))
                                 {
                                     foreach (var tag in contract.Tags.Select(i => i.Value).DefaultIfEmpty(null))
@@ -265,7 +264,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                                         var contextTag = GetContextTag(injection, newNode);
                                         var newInjection = injection with { Tag = contextTag ?? injection.Tag };
                                         UpdateMap(newInjection, newNode);
-                                        var processingNode = CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode);
+                                        var processingNode = CreateNewProcessingNode(newInjection.Tag, newNode);
                                         queue.Enqueue(processingNode);
                                     }
 
@@ -274,7 +273,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                         }
 
                         // OnCannotResolve
-                        if (TryCreateOnCannotResolve(nodesCache, setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))
+                        if (TryCreateOnCannotResolve(setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))
                         {
                             continue;
                         }
@@ -300,7 +299,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                             var contextTag = GetContextTag(injection, newNode);
                             var newInjection = injection with { Tag = contextTag ?? injection.Tag };
                             UpdateMap(newInjection, newNode);
-                            queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode));
+                            queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, newNode));
                         }
 
                         continue;
@@ -358,7 +357,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                         var contextTag = GetContextTag(injection, newNode);
                         var newInjection = injection with { Tag = contextTag ?? injection.Tag };
                         UpdateMap(newInjection, newNode);
-                        queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode));
+                        queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, newNode));
                     }
 
                     continue;
@@ -383,6 +382,11 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
 
                     if (!disableAutoBinding)
                     {
+                        /*if (!Debugger.IsAttached)
+                        {
+                            Debugger.Launch();
+                        }*/
+
                         var autoBinding = bindingsFactory.CreateAutoBinding(setup, targetNode, injection, typeConstructor, ++maxBindingId);
                         var autoNodes = dependencyNodePrioritizer.SortByPriority(nodesFactory.CreateNodes(setup, typeConstructor, autoBinding)).ToList();
                         foreach (var autoNode in autoNodes)
@@ -399,7 +403,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                         {
                             var contextTag = GetContextTag(injection, newNode);
                             var newInjection = injection with { Tag = contextTag ?? injection.Tag };
-                            var newProcessingNode = CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode);
+                            var newProcessingNode = CreateNewProcessingNode(newInjection.Tag, newNode);
                             UpdateMap(newInjection, newNode);
                             queue.Enqueue(newProcessingNode);
                         }
@@ -409,7 +413,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)
                 }
 
                 // OnCannotResolve
-                if (TryCreateOnCannotResolve(nodesCache, setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))
+                if (TryCreateOnCannotResolve(setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))
                 {
                     continue;
                 }
@@ -513,9 +517,7 @@ private MdConstructKind GetConstructKind(INamedTypeSymbol geneticType)
         });
     }
 
-    private bool TryCreateOnCannotResolve(
-        ICache<ProcessingNodeKey, IProcessingNode> nodesCache,
-        MdSetup setup,
+    private bool TryCreateOnCannotResolve(MdSetup setup,
         ITypeConstructor typeConstructor,
         DependencyNode ownerNode,
         Injection unresolvedInjection,
@@ -549,7 +551,7 @@ private bool TryCreateOnCannotResolve(
                 foreach (var onCannotResolveNode in onCannotResolveNodes)
                 {
                     map[unresolvedInjection] = onCannotResolveNode;
-                    processed.Add(CreateNewProcessingNode(nodesCache, unresolvedInjection.Tag, onCannotResolveNode));
+                    processed.Add(CreateNewProcessingNode(unresolvedInjection.Tag, onCannotResolveNode));
                     return true;
                 }
             }
@@ -558,8 +560,8 @@ private bool TryCreateOnCannotResolve(
         return false;
     }
 
-    private IProcessingNode CreateNewProcessingNode(ICache<ProcessingNodeKey, IProcessingNode> nodesCache, object? contextTag, DependencyNode dependencyNode) =>
-        processingNodeBuilder.Build(new ProcessingNodeContext(nodesCache, dependencyNode, contextTag));
+    private IProcessingNode CreateNewProcessingNode(object? contextTag, DependencyNode dependencyNode) =>
+        processingNodeBuilder.Build(new ProcessingNodeContext(dependencyNode, contextTag));
 
     private static object? GetContextTag(Injection injection, DependencyNode node) =>
         node.Factory is { Source.HasContextTag: true } ? injection.Tag : null;
diff --git a/src/Pure.DI.Core/Core/LocalCache.cs b/src/Pure.DI.Core/Core/LocalCache.cs
diff --git a/src/Pure.DI.Core/Core/Models/GraphBuildContext.cs b/src/Pure.DI.Core/Core/Models/GraphBuildContext.cs
@@ -3,8 +3,7 @@
 record GraphBuildContext(
     MdSetup Setup,
     in ImmutableArray<IProcessingNode> Nodes,
-    in ImmutableDictionary<ISymbol, ImmutableArray<MdAccumulator>> Accumulators,
-    ICache<ProcessingNodeKey, IProcessingNode> NodesCache)
+    in ImmutableDictionary<ISymbol, ImmutableArray<MdAccumulator>> Accumulators)
 {
     public IGraph<DependencyNode, Dependency>? Graph { get; set; }
 }
diff --git a/src/Pure.DI.Core/Core/Models/ProcessingNodeContext.cs b/src/Pure.DI.Core/Core/Models/ProcessingNodeContext.cs
@@ -1,7 +1,6 @@
 ﻿namespace Pure.DI.Core.Models;
 
 readonly record struct ProcessingNodeContext(
-    ICache<ProcessingNodeKey, IProcessingNode> Cache,
     DependencyNode Node,
     object? ContextTag,
     ISet<Injection>? Contracts = null);
diff --git a/src/Pure.DI.Core/Core/ProcessingNodeBuilder.cs b/src/Pure.DI.Core/Core/ProcessingNodeBuilder.cs
@@ -5,15 +5,14 @@ class ProcessingNodeBuilder(
     Func<IInjectionsWalker> injectionsWalkerFactory)
     : IFastBuilder<ProcessingNodeContext, IProcessingNode>
 {
-    public IProcessingNode Build(in ProcessingNodeContext ctx) =>
-        ctx.Cache.Get(new ProcessingNodeKey(ctx.Node.Variation, ctx.Node, ctx.ContextTag) { Contracts =  ctx.Contracts }, Build);
-
-    private IProcessingNode Build(ProcessingNodeKey key)
+    public IProcessingNode Build(in ProcessingNodeContext ctx)
     {
-        var contracts = key.Contracts ?? contractsBuilder.Build(new ContractsBuildContext(key.Node.Binding, key.ContextTag, key.ContextTag));
+        var node = ctx.Node;
+        var tag = ctx.ContextTag;
+        var contracts = ctx.Contracts ?? contractsBuilder.Build(new ContractsBuildContext(node.Binding, tag, tag));
         var injectionsWalker = injectionsWalkerFactory();
-        injectionsWalker.VisitDependencyNode(Unit.Shared, key.Node);
+        injectionsWalker.VisitDependencyNode(Unit.Shared, node);
         var injections = injectionsWalker.GetResult();
-        return new ProcessingNode(key.Node, contracts, injections);
+        return new ProcessingNode(node, contracts, injections);
     }
 }
diff --git a/src/Pure.DI.Core/Core/VariationalDependencyGraphBuilder.cs b/src/Pure.DI.Core/Core/VariationalDependencyGraphBuilder.cs
@@ -20,7 +20,6 @@ sealed class VariationalDependencyGraphBuilder(
     IFastBuilder<ProcessingNodeContext, IProcessingNode> processingNodeBuilder,
     IRegistryManager<int> bindingsRegistryManager,
     ILocationProvider locationProvider,
-    [Tag(Tag.LocalCache)] Func<ICache<ProcessingNodeKey, IProcessingNode>> nodesCacheFactory,
     IDependencyNodePrioritizer dependencyNodePrioritizer,
     CancellationToken cancellationToken)
     : IBuilder<MdSetup, DependencyGraph?>
@@ -32,7 +31,6 @@ sealed class VariationalDependencyGraphBuilder(
         var allNodes = new List<IProcessingNode>();
         var injections = new Dictionary<Injection, DependencyNode>();
         var allOverriddenInjections = new HashSet<Injection>();
-        var nodesCache = nodesCacheFactory();
         foreach (var node in rawNodes)
         {
             var contracts = contractsBuilder.Build(new ContractsBuildContext(node.Binding, MdTag.ContextTag, MdTag.AnyTag));
@@ -80,7 +78,7 @@ sealed class VariationalDependencyGraphBuilder(
 
             if (isRoot || contracts.Count > 0)
             {
-                allNodes.Add(processingNodeBuilder.Build(new ProcessingNodeContext(nodesCache, node, MdTag.ContextTag, contracts)));
+                allNodes.Add(processingNodeBuilder.Build(new ProcessingNodeContext(node, MdTag.ContextTag, contracts)));
             }
         }
 
@@ -89,14 +87,16 @@ sealed class VariationalDependencyGraphBuilder(
         var maxIterations = globalProperties.MaxIterations;
         var maxAttempts = 0x2000;
         DependencyGraph? dependencyGraph = null;
+
         var accumulators = setup.Accumulators
             .GroupBy(acc => acc.AccumulatorType, SymbolEqualityComparer.Default)
             .ToImmutableDictionary(i => i.Key!, i => i.ToImmutableArray(), SymbolEqualityComparer.Default);
+
         var buildCtx = new GraphBuildContext(
             setup,
             ImmutableArray<IProcessingNode>.Empty,
-            accumulators,
-            nodesCache);
+            accumulators);
+
         while (nodeVariator.TryGetNext(setsOfOptions, out var nodes))
         {
             if (maxAttempts-- <= 0)
@@ -167,14 +167,15 @@ sealed class VariationalDependencyGraphBuilder(
 
             IProcessingNode CreateProcessingNode(DependencyNode dependencyNode)
             {
-                var processingNode = processingNodeBuilder.Build(new ProcessingNodeContext(nodesCache, dependencyNode, MdTag.ContextTag, contractsBuilder.Build(new ContractsBuildContext(dependencyNode.Binding, MdTag.ContextTag, MdTag.AnyTag))));
+                var processingNode = processingNodeBuilder.Build(new ProcessingNodeContext(dependencyNode, MdTag.ContextTag, contractsBuilder.Build(new ContractsBuildContext(dependencyNode.Binding, MdTag.ContextTag, MdTag.AnyTag))));
                 allNodes.Add(processingNode);
                 return processingNode;
             }
         }
 
         return dependencyGraph;
     }
+
     private void RegisterNode(MdSetup setup, DependencyNode node)
     {
         var binding = node.Binding;
diff --git a/src/Pure.DI.Core/Generator.cs b/src/Pure.DI.Core/Generator.cs
@@ -59,7 +59,6 @@ private void Setup() => DI.Setup()
             .Transient(_ => Compiled | CultureInvariant | Singleline | IgnoreCase)
             .Transient((RegexOptions options) => new Func<string, Regex>(p => new Regex(p, options)))
             .Transient<ApiInvocationProcessor, DependencyGraphBuilder, TypeConstructor, BindingBuilder, SetupContextRewriter, SetupContextMembersCollector>()
-            .Transient<LocalCache<TT1, TT2>>(LocalCache)
 
             // Walkers
             .SpecialType<CSharpSyntaxRewriter>()
diff --git a/tests/Pure.DI.IntegrationTests/OverrideTests.cs b/tests/Pure.DI.IntegrationTests/OverrideTests.cs

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,6 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`33`	`33`	`var setup = ctx.Setup;`
`34`	`34`	`var nodes = ctx.Nodes;`
`35`	`35`	`var accumulators = ctx.Accumulators;`
`36`		`- var nodesCache = ctx.NodesCache;`
`37`	`36`	`var nodesLength = nodes.Length;`
`38`	`37`	`var map = new Dictionary<Injection, DependencyNode>(nodesLength);`
`39`	`38`	`var contextMap = new Dictionary<Injection, DependencyNode>(nodesLength);`
`@@ -120,7 +119,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`120`	`119`	`var contextTag = GetContextTag(injection, newNode);`
`121`	`120`	`var newInjection = injection with { Tag = contextTag ?? injection.Tag };`
`122`	`121`	`edges.Add(new Dependency(true, newNode, newInjection, targetNode, position));`
`123`		`- queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode));`
	`122`	`+ queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, newNode));`
`124`	`123`	`}`
`125`	`124`
`126`	`125`	`continue;`
`@@ -135,7 +134,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`135`	`134`	`{`
`136`	`135`	`if (!marker.IsMarkerBased(setup, sourceNode!.Type))`
`137`	`136`	`{`
`138`		`- queue.Enqueue(CreateNewProcessingNode(nodesCache, injection.Tag, sourceNode));`
	`137`	`+ queue.Enqueue(CreateNewProcessingNode(injection.Tag, sourceNode));`
`139`	`138`	`continue;`
`140`	`139`	`}`
`141`	`140`	`}`
`@@ -156,7 +155,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`156`	`155`	`{`
`157`	`156`	`var contextTag = GetContextTag(injection, newNode);`
`158`	`157`	`var newInjection = injection with { Tag = contextTag ?? injection.Tag };`
`159`		`- var newProcessingNode = CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode);`
	`158`	`+ var newProcessingNode = CreateNewProcessingNode(newInjection.Tag, newNode);`
`160`	`159`	`UpdateMap(newInjection, newNode);`
`161`	`160`	`queue.Enqueue(newProcessingNode);`
`162`	`161`	`}`
`@@ -207,7 +206,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`207`	`206`	`if (genericNode is not null)`
`208`	`207`	`{`
`209`	`208`	`UpdateMap(newInjection, genericNode);`
`210`		`- queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, genericNode));`
	`209`	`+ queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, genericNode));`
`211`	`210`	`foreach (var contract in genericBinding.Contracts.Where(i => i.ContractType is not null))`
`212`	`211`	`{`
`213`	`212`	`foreach (var tag in contract.Tags.Select(i => i.Value).DefaultIfEmpty(null))`
`@@ -265,7 +264,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`265`	`264`	`var contextTag = GetContextTag(injection, newNode);`
`266`	`265`	`var newInjection = injection with { Tag = contextTag ?? injection.Tag };`
`267`	`266`	`UpdateMap(newInjection, newNode);`
`268`		`- var processingNode = CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode);`
	`267`	`+ var processingNode = CreateNewProcessingNode(newInjection.Tag, newNode);`
`269`	`268`	`queue.Enqueue(processingNode);`
`270`	`269`	`}`
`271`	`270`
`@@ -274,7 +273,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`274`	`273`	`}`
`275`	`274`
`276`	`275`	`// OnCannotResolve`
`277`		`- if (TryCreateOnCannotResolve(nodesCache, setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))`
	`276`	`+ if (TryCreateOnCannotResolve(setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))`
`278`	`277`	`{`
`279`	`278`	`continue;`
`280`	`279`	`}`
`@@ -300,7 +299,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`300`	`299`	`var contextTag = GetContextTag(injection, newNode);`
`301`	`300`	`var newInjection = injection with { Tag = contextTag ?? injection.Tag };`
`302`	`301`	`UpdateMap(newInjection, newNode);`
`303`		`- queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode));`
	`302`	`+ queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, newNode));`
`304`	`303`	`}`
`305`	`304`
`306`	`305`	`continue;`
`@@ -358,7 +357,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`358`	`357`	`var contextTag = GetContextTag(injection, newNode);`
`359`	`358`	`var newInjection = injection with { Tag = contextTag ?? injection.Tag };`
`360`	`359`	`UpdateMap(newInjection, newNode);`
`361`		`- queue.Enqueue(CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode));`
	`360`	`+ queue.Enqueue(CreateNewProcessingNode(newInjection.Tag, newNode));`
`362`	`361`	`}`
`363`	`362`
`364`	`363`	`continue;`
`@@ -383,6 +382,11 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`383`	`382`
`384`	`383`	`if (!disableAutoBinding)`
`385`	`384`	`{`
	`385`	`+ /*if (!Debugger.IsAttached)`
	`386`	`+ {`
	`387`	`+ Debugger.Launch();`
	`388`	`+ }*/`
	`389`	`+`
`386`	`390`	`var autoBinding = bindingsFactory.CreateAutoBinding(setup, targetNode, injection, typeConstructor, ++maxBindingId);`
`387`	`391`	`var autoNodes = dependencyNodePrioritizer.SortByPriority(nodesFactory.CreateNodes(setup, typeConstructor, autoBinding)).ToList();`
`388`	`392`	`foreach (var autoNode in autoNodes)`
`@@ -399,7 +403,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`399`	`403`	`{`
`400`	`404`	`var contextTag = GetContextTag(injection, newNode);`
`401`	`405`	`var newInjection = injection with { Tag = contextTag ?? injection.Tag };`
`402`		`- var newProcessingNode = CreateNewProcessingNode(nodesCache, newInjection.Tag, newNode);`
	`406`	`+ var newProcessingNode = CreateNewProcessingNode(newInjection.Tag, newNode);`
`403`	`407`	`UpdateMap(newInjection, newNode);`
`404`	`408`	`queue.Enqueue(newProcessingNode);`
`405`	`409`	`}`
`@@ -409,7 +413,7 @@ public IEnumerable<DependencyNode> Build(GraphBuildContext ctx)`
`409`	`413`	`}`
`410`	`414`
`411`	`415`	`// OnCannotResolve`
`412`		`- if (TryCreateOnCannotResolve(nodesCache, setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))`
	`416`	`+ if (TryCreateOnCannotResolve(setup, typeConstructor, targetNode, injection, ref maxBindingId, map, processed))`
`413`	`417`	`{`
`414`	`418`	`continue;`
`415`	`419`	`}`
`@@ -513,9 +517,7 @@ private MdConstructKind GetConstructKind(INamedTypeSymbol geneticType)`
`513`	`517`	`});`
`514`	`518`	`}`
`515`	`519`
`516`		`- private bool TryCreateOnCannotResolve(`
`517`		`- ICache<ProcessingNodeKey, IProcessingNode> nodesCache,`
`518`		`- MdSetup setup,`
	`520`	`+ private bool TryCreateOnCannotResolve(MdSetup setup,`
`519`	`521`	`ITypeConstructor typeConstructor,`
`520`	`522`	`DependencyNode ownerNode,`
`521`	`523`	`Injection unresolvedInjection,`
`@@ -549,7 +551,7 @@ private bool TryCreateOnCannotResolve(`
`549`	`551`	`foreach (var onCannotResolveNode in onCannotResolveNodes)`
`550`	`552`	`{`
`551`	`553`	`map[unresolvedInjection] = onCannotResolveNode;`
`552`		`- processed.Add(CreateNewProcessingNode(nodesCache, unresolvedInjection.Tag, onCannotResolveNode));`
	`554`	`+ processed.Add(CreateNewProcessingNode(unresolvedInjection.Tag, onCannotResolveNode));`
`553`	`555`	`return true;`
`554`	`556`	`}`
`555`	`557`	`}`
`@@ -558,8 +560,8 @@ private bool TryCreateOnCannotResolve(`
`558`	`560`	`return false;`
`559`	`561`	`}`
`560`	`562`
`561`		`- private IProcessingNode CreateNewProcessingNode(ICache<ProcessingNodeKey, IProcessingNode> nodesCache, object? contextTag, DependencyNode dependencyNode) =>`
`562`		`- processingNodeBuilder.Build(new ProcessingNodeContext(nodesCache, dependencyNode, contextTag));`
	`563`	`+ private IProcessingNode CreateNewProcessingNode(object? contextTag, DependencyNode dependencyNode) =>`
	`564`	`+ processingNodeBuilder.Build(new ProcessingNodeContext(dependencyNode, contextTag));`
`563`	`565`
`564`	`566`	`private static object? GetContextTag(Injection injection, DependencyNode node) =>`
`565`	`567`	`node.Factory is { Source.HasContextTag: true } ? injection.Tag : null;`
Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,7 @@`
`3`	`3`	`record GraphBuildContext(`
`4`	`4`	`MdSetup Setup,`
`5`	`5`	`in ImmutableArray<IProcessingNode> Nodes,`
`6`		`- in ImmutableDictionary<ISymbol, ImmutableArray<MdAccumulator>> Accumulators,`
`7`		`- ICache<ProcessingNodeKey, IProcessingNode> NodesCache)`
	`6`	`+ in ImmutableDictionary<ISymbol, ImmutableArray<MdAccumulator>> Accumulators)`
`8`	`7`	`{`
`9`	`8`	`public IGraph<DependencyNode, Dependency>? Graph { get; set; }`
`10`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,14 @@ class ProcessingNodeBuilder(`
`5`	`5`	`Func<IInjectionsWalker> injectionsWalkerFactory)`
`6`	`6`	`: IFastBuilder<ProcessingNodeContext, IProcessingNode>`
`7`	`7`	`{`
`8`		`- public IProcessingNode Build(in ProcessingNodeContext ctx) =>`
`9`		`- ctx.Cache.Get(new ProcessingNodeKey(ctx.Node.Variation, ctx.Node, ctx.ContextTag) { Contracts = ctx.Contracts }, Build);`
`10`		`-`
`11`		`- private IProcessingNode Build(ProcessingNodeKey key)`
	`8`	`+ public IProcessingNode Build(in ProcessingNodeContext ctx)`
`12`	`9`	`{`
`13`		`- var contracts = key.Contracts ?? contractsBuilder.Build(new ContractsBuildContext(key.Node.Binding, key.ContextTag, key.ContextTag));`
	`10`	`+ var node = ctx.Node;`
	`11`	`+ var tag = ctx.ContextTag;`
	`12`	`+ var contracts = ctx.Contracts ?? contractsBuilder.Build(new ContractsBuildContext(node.Binding, tag, tag));`
`14`	`13`	`var injectionsWalker = injectionsWalkerFactory();`
`15`		`- injectionsWalker.VisitDependencyNode(Unit.Shared, key.Node);`
	`14`	`+ injectionsWalker.VisitDependencyNode(Unit.Shared, node);`
`16`	`15`	`var injections = injectionsWalker.GetResult();`
`17`		`- return new ProcessingNode(key.Node, contracts, injections);`
	`16`	`+ return new ProcessingNode(node, contracts, injections);`
`18`	`17`	`}`
`19`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,6 @@ sealed class VariationalDependencyGraphBuilder(`
`20`	`20`	`IFastBuilder<ProcessingNodeContext, IProcessingNode> processingNodeBuilder,`
`21`	`21`	`IRegistryManager<int> bindingsRegistryManager,`
`22`	`22`	`ILocationProvider locationProvider,`
`23`		`- [Tag(Tag.LocalCache)] Func<ICache<ProcessingNodeKey, IProcessingNode>> nodesCacheFactory,`
`24`	`23`	`IDependencyNodePrioritizer dependencyNodePrioritizer,`
`25`	`24`	`CancellationToken cancellationToken)`
`26`	`25`	`: IBuilder<MdSetup, DependencyGraph?>`
`@@ -32,7 +31,6 @@ sealed class VariationalDependencyGraphBuilder(`
`32`	`31`	`var allNodes = new List<IProcessingNode>();`
`33`	`32`	`var injections = new Dictionary<Injection, DependencyNode>();`
`34`	`33`	`var allOverriddenInjections = new HashSet<Injection>();`
`35`		`- var nodesCache = nodesCacheFactory();`
`36`	`34`	`foreach (var node in rawNodes)`
`37`	`35`	`{`
`38`	`36`	`var contracts = contractsBuilder.Build(new ContractsBuildContext(node.Binding, MdTag.ContextTag, MdTag.AnyTag));`
`@@ -80,7 +78,7 @@ sealed class VariationalDependencyGraphBuilder(`
`80`	`78`
`81`	`79`	`if (isRoot \|\| contracts.Count > 0)`
`82`	`80`	`{`
`83`		`- allNodes.Add(processingNodeBuilder.Build(new ProcessingNodeContext(nodesCache, node, MdTag.ContextTag, contracts)));`
	`81`	`+ allNodes.Add(processingNodeBuilder.Build(new ProcessingNodeContext(node, MdTag.ContextTag, contracts)));`
`84`	`82`	`}`
`85`	`83`	`}`
`86`	`84`
`@@ -89,14 +87,16 @@ sealed class VariationalDependencyGraphBuilder(`
`89`	`87`	`var maxIterations = globalProperties.MaxIterations;`
`90`	`88`	`var maxAttempts = 0x2000;`
`91`	`89`	`DependencyGraph? dependencyGraph = null;`
	`90`	`+`
`92`	`91`	`var accumulators = setup.Accumulators`
`93`	`92`	`.GroupBy(acc => acc.AccumulatorType, SymbolEqualityComparer.Default)`
`94`	`93`	`.ToImmutableDictionary(i => i.Key!, i => i.ToImmutableArray(), SymbolEqualityComparer.Default);`
	`94`	`+`
`95`	`95`	`var buildCtx = new GraphBuildContext(`
`96`	`96`	`setup,`
`97`	`97`	`ImmutableArray<IProcessingNode>.Empty,`
`98`		`- accumulators,`
`99`		`- nodesCache);`
	`98`	`+ accumulators);`
	`99`	`+`
`100`	`100`	`while (nodeVariator.TryGetNext(setsOfOptions, out var nodes))`
`101`	`101`	`{`
`102`	`102`	`if (maxAttempts-- <= 0)`
`@@ -167,14 +167,15 @@ sealed class VariationalDependencyGraphBuilder(`
`167`	`167`
`168`	`168`	`IProcessingNode CreateProcessingNode(DependencyNode dependencyNode)`
`169`	`169`	`{`
`170`		`- var processingNode = processingNodeBuilder.Build(new ProcessingNodeContext(nodesCache, dependencyNode, MdTag.ContextTag, contractsBuilder.Build(new ContractsBuildContext(dependencyNode.Binding, MdTag.ContextTag, MdTag.AnyTag))));`
	`170`	`+ var processingNode = processingNodeBuilder.Build(new ProcessingNodeContext(dependencyNode, MdTag.ContextTag, contractsBuilder.Build(new ContractsBuildContext(dependencyNode.Binding, MdTag.ContextTag, MdTag.AnyTag))));`
`171`	`171`	`allNodes.Add(processingNode);`
`172`	`172`	`return processingNode;`
`173`	`173`	`}`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`return dependencyGraph;`
`177`	`177`	`}`
	`178`	`+`
`178`	`179`	`private void RegisterNode(MdSetup setup, DependencyNode node)`
`179`	`180`	`{`
`180`	`181`	`var binding = node.Binding;`