Sometimes value overrides are performed on undefined variables

Author: NikolayPianikov

src/Pure.DI.Core/Core/ApiInvocationProcessor.cs

@@ -174,8 +174,9 @@ MemberAccessExpressionSyntax memberAccess when memberAccess.Kind() == SyntaxKind
                                 ImmutableArray<MdTagAttribute>.Empty,
                                 ImmutableArray<MdOrdinalAttribute>.Empty,
                                 ImmutableArray<MdAccumulator>.Empty,
-                                Array.Empty<MdTagOnSites>(),
-                                comments.FilterHints(invocationComments).ToList()));
+                                [],
+                                comments.FilterHints(invocationComments).ToList(),
+                                null));
                         break;
 
                     case nameof(IConfiguration.DefaultLifetime):

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

@@ -12,6 +12,7 @@ sealed class CompositionBuilder(
     ICodeBuilder<IStatement> statementBuilder,
     IBuilder<CompositionCode, LinesBuilder> classDiagramBuilder,
     Func<IVariablesMap> variablesMapFactory,
+    IVariableNameProvider variableNameProvider,
     CancellationToken cancellationToken)
     : IBuilder<DependencyGraph, CompositionCode>
 {
@@ -48,9 +49,13 @@ public CompositionCode Build(DependencyGraph graph)
                 }
             }
 
-            foreach (var overrideVar in map.GetOverrides())
+            if (graph.Source.Overrides is {} overrides)
             {
-                ctx.Code.AppendLine($"{typeResolver.Resolve(graph.Source, overrideVar.InstanceType)} {overrideVar.VariableName};");
+                foreach (var @override in overrides.GetOverrides(root.Node))
+                {
+                    var variableName = variableNameProvider.GetOverrideVariableName(@override.Source);
+                    ctx.Code.AppendLine($"{typeResolver.Resolve(graph.Source, @override.Source.ContractType)} {variableName};");
+                }
             }
 
             blockBuilder.Build(ctx, rootBlock);

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

@@ -9,6 +9,4 @@ interface IVariablesMap : IDictionary<MdBinding, Variable>
     IEnumerable<Variable> GetSingletons();
 
     IEnumerable<Variable> GetPerResolves();
-
-    IEnumerable<Variable> GetOverrides();
 }

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

@@ -28,10 +28,6 @@ public IEnumerable<Variable> GetSingletons() => this
         this.Any(i => i.Key.Lifetime?.Value is Lifetime.Singleton or Lifetime.Scoped or Lifetime.PerResolve);
 
     public IEnumerable<Variable> GetPerResolves() => this
-        .Where(i => i.Key.Lifetime?.Value == Lifetime.PerResolve && i.Key.Construct is not { Kind: MdConstructKind.Override })
-        .Select(i => i.Value);
-
-    public IEnumerable<Variable> GetOverrides() => this
-        .Where(i => i.Key.Construct is { Kind: MdConstructKind.Override })
+        .Where(i => i.Key.Lifetime?.Value == Lifetime.PerResolve)
         .Select(i => i.Value);
 }

src/Pure.DI.Core/Core/GraphOverrider.cs

@@ -17,7 +17,7 @@ public IGraph<DependencyNode, Dependency> Rewrite(
         var nodesMap = new Dictionary<Injection, DependencyNode>();
         foreach (var rootNode in from node in graph.Vertices where node.Root is not null select node)
         {
-            Override(processedNodes, [], nodesMap, [], setup, graph, rootNode, ref maxId, entries);
+            Override(processedNodes, [], nodesMap, [], setup, graph, rootNode, rootNode, ref maxId, entries);
             if (cancellationToken.IsCancellationRequested)
             {
                 return graph;
@@ -46,6 +46,7 @@ private DependencyNode Override(
         Dictionary<int, DpOverride> overridesMap,
         MdSetup setup,
         IGraph<DependencyNode, Dependency> graph,
+        DependencyNode rootNode,
         DependencyNode targetNode,
         ref int maxId,
         List<GraphEntry<DependencyNode, Dependency>> entries)
@@ -83,6 +84,11 @@ private DependencyNode Override(
                 return targetNode;
             }
 
+            if (targetNode.Root is not null)
+            {
+                rootNode = dependency.Source;
+            }
+
             if (dependency.Position.HasValue)
             {
                 while (lastDependencyPosition < dependency.Position && overridesEnumerator.MoveNext())
@@ -102,6 +108,7 @@ private DependencyNode Override(
                             @override.Source with { Id = overrideId, ContractType = contractType },
                             @override.Injections.Select(i => i with { Type = typeConstructor.Construct(setup, i.Type) }).ToImmutableArray());
 
+                        setup.Overrides?.Register(rootNode, currentOverride);
                         overridesMap[@override.Source.Id] = currentOverride;
                         MdBinding? overrideBinding = null;
                         foreach (var injection in currentOverride.Injections)
@@ -122,7 +129,7 @@ private DependencyNode Override(
                                 targetNode,
                                 injection,
                                 contractType,
-                                Lifetime.PerResolve,
+                                Lifetime.Transient,
                                 typeConstructor,
                                 ++maxId,
                                 MdConstructKind.Override,
@@ -141,7 +148,7 @@ private DependencyNode Override(
             if (!overriddenInjections.Contains(currentDependency.Injection)
                 || !nodesMap.TryGetValue(currentDependency.Injection, out var overridingSourceNode))
             {
-                var source = Override(processedNodes, overriddenInjections, nodesMap, overridesMap, setup, graph, currentDependency.Source, ref maxId, entries);
+                var source = Override(processedNodes, overriddenInjections, nodesMap, overridesMap, setup, graph, rootNode, currentDependency.Source, ref maxId, entries);
                 currentDependency = currentDependency with { Source = source };
             }
             else

src/Pure.DI.Core/Core/IOverridesRegistry.cs

@@ -0,0 +1,8 @@
+namespace Pure.DI.Core;
+
+interface IOverridesRegistry
+{
+    void Register(DependencyNode rootNode, DpOverride @override);
+
+    IEnumerable<DpOverride> GetOverrides(DependencyNode rootNode);
+}

src/Pure.DI.Core/Core/MetadataBuilder.cs

@@ -13,6 +13,7 @@ sealed class MetadataBuilder(
     Func<IBuilder<SyntaxUpdate, IEnumerable<MdSetup>>> setupsBuilderFactory,
     Func<ISetupFinalizer> setupFinalizerFactory,
     ICompilations compilations,
+    Func<IOverridesRegistry> overridesFactory,
     CancellationToken cancellationToken)
     : IBuilder<IEnumerable<SyntaxUpdate>, IEnumerable<MdSetup>>
 {
@@ -187,6 +188,7 @@ private void MergeSetups(IEnumerable<MdSetup> setups, out MdSetup mergedSetup, b
             ordinalAttributesBuilder.ToImmutable(),
             accumulators.ToImmutable(),
             tagOn,
-            comments);
+            comments,
+            overridesFactory());
     }
 }

src/Pure.DI.Core/Core/Models/MdSetup.cs

@@ -21,7 +21,8 @@ record MdSetup(
     in ImmutableArray<MdOrdinalAttribute> OrdinalAttributes,
     in ImmutableArray<MdAccumulator> Accumulators,
     IReadOnlyCollection<MdTagOnSites> TagOn,
-    IReadOnlyCollection<string> Comments)
+    IReadOnlyCollection<string> Comments,
+    IOverridesRegistry? Overrides)
 {
     public virtual bool Equals(MdSetup? other) =>
         other is not null && (ReferenceEquals(this, other) || Name.Equals(other.Name));

src/Pure.DI.Core/Core/OverridesRegistry.cs

@@ -0,0 +1,19 @@
+namespace Pure.DI.Core;
+
+using System.Collections.Concurrent;
+
+class OverridesRegistry : IOverridesRegistry
+{
+    private readonly ConcurrentDictionary<int, List<DpOverride>> _overrides = new();
+
+    public void Register(DependencyNode rootNode, DpOverride @override) =>
+        _overrides.AddOrUpdate(rootNode.Binding.Id, _ => [@override], (_, list) => {
+            list.Add(@override);
+            return list;
+        });
+
+    public IEnumerable<DpOverride> GetOverrides(DependencyNode rootNode) =>
+        _overrides.TryGetValue(rootNode.Binding.Id, out var overrides)
+            ? overrides.GroupBy(i => i.Source.Id).Select(i => i.First()).ToList()
+            : [];
+}

src/Pure.DI.Core/Generator.cs

@@ -71,6 +71,7 @@ private void Setup() => DI.Setup()
             .Bind<IDependencyGraphLocationsWalker>().To<DependencyGraphLocationsWalker>()
             .Bind<IFactoryValidator>().To<FactoryValidator>()
             .Bind<ILocalVariableRenamingRewriter>().To<LocalVariableRenamingRewriter>()
+            .Bind().To<OverridesRegistry>()
 
         .DefaultLifetime(Singleton)
             .Bind().To<Cache<TT1, TT2>>()