#136 Insufficient performance 4

Author: NikolayPianikov

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

@@ -12,6 +12,7 @@ class VarsMap(
     : IVarsMap
 {
     private readonly Dictionary<int, Var> _map = [];
+    private static readonly IReadOnlyDictionary<int, VarState> EmptyState = new Dictionary<int, VarState>();
 
     /// <inheritdoc />
     public IEnumerable<Var> Vars => _map.Values;
@@ -101,7 +102,7 @@ public IDisposable LocalFunction(Var var, Lines lines)
         var state = CreateState(var);
 
         // Per-block variables should be isolated between local functions.
-        var removed = new List<KeyValuePair<int, Var>>();
+        List<KeyValuePair<int, Var>>? removed = null;
         foreach (var item in _map)
         {
             if (item.Value.AbstractNode.ActualLifetime is not Lifetime.PerBlock)
@@ -112,18 +113,26 @@ public IDisposable LocalFunction(Var var, Lines lines)
 #if DEBUG
             lines.AppendLine($"// {item.Value.Declaration.Name}: remove ({nameof(LocalFunction)})");
 #endif
-            removed.Add(item);
+            (removed ??= []).Add(item);
         }
 
-        foreach (var item in removed)
+        if (removed is not null)
         {
-            _map.Remove(item.Key);
+            foreach (var item in removed)
+            {
+                _map.Remove(item.Key);
+            }
         }
 
         return Disposables.Create(() => {
             // Cleanup and restore state after exiting the local function.
             RemoveNewNonPersistentVars(var, state, lines, nameof(LocalFunction));
             RestoreState(var, state, lines, nameof(LocalFunction), false);
+            if (removed is null)
+            {
+                return;
+            }
+
             foreach (var item in removed)
             {
 #if DEBUG
@@ -184,10 +193,10 @@ node.ActualLifetime is Lifetime.PerBlock
     /// Global code state (like LocalFunction) is NOT part of the snapshot because it should accumulate.
     /// Only path-specific state (IsDeclared, IsCreated, CodeExpression) is captured.
     /// </summary>
-    private Dictionary<int, VarState> CreateState(Var var)
+    private IReadOnlyDictionary<int, VarState> CreateState(Var var)
     {
         var excludeBindingId = var.AbstractNode.BindingId;
-        var result = new Dictionary<int, VarState>(_map.Count);
+        Dictionary<int, VarState>? result = null;
         foreach (var item in _map)
         {
             if (item.Key == excludeBindingId)
@@ -201,10 +210,10 @@ private Dictionary<int, VarState> CreateState(Var var)
                 continue;
             }
 
-            result[item.Key] = new VarState(item.Value);
+            (result ??= new Dictionary<int, VarState>(_map.Count))[item.Key] = new VarState(item.Value);
         }
 
-        return result;
+        return result ?? EmptyState;
     }
 
     /// <summary>
@@ -225,7 +234,7 @@ private void RemoveNewNonPersistentVars(Var var, IReadOnlyDictionary<int, VarSta
             return;
         }
 
-        var newItems = new List<KeyValuePair<int, Var>>();
+        List<KeyValuePair<int, Var>>? newItems = null;
         foreach (var item in _map)
         {
             if (state.ContainsKey(item.Key))
@@ -239,18 +248,23 @@ private void RemoveNewNonPersistentVars(Var var, IReadOnlyDictionary<int, VarSta
                 if (!IsNestedScopePersistentNode(node)
                     && !ShouldKeepCurrentNodeInNestedScope(node))
                 {
-                    newItems.Add(item);
+                    (newItems ??= []).Add(item);
                 }
 
                 continue;
             }
 
             if (!IsNestedScopePersistentNode(node))
             {
-                newItems.Add(item);
+                (newItems ??= []).Add(item);
             }
         }
 
+        if (newItems is null)
+        {
+            return;
+        }
+
         foreach (var item in newItems)
         {
 #if DEBUG
@@ -337,21 +351,25 @@ private void RestoreState(Var var, IReadOnlyDictionary<int, VarState> state, Lin
         }
     }
 
-    private readonly record struct VarState(
-        Var Var,
-        bool IsDeclared,
-        bool IsCreated,
-        bool IsLocalFunctionCalled,
-        string? RawCodeExpression)
+    private readonly struct VarState
     {
+        public readonly Var Var;
+
+        public readonly bool IsDeclared;
+
+        public readonly bool IsCreated;
+
+        public readonly bool IsLocalFunctionCalled;
+
+        public readonly string? RawCodeExpression;
+
         public VarState(Var variable)
-            : this(
-                variable,
-                variable.Declaration.IsDeclared,
-                variable.IsCreated,
-                variable.IsLocalFunctionCalled,
-                variable.RawCodeExpression)
         {
+            Var = variable;
+            IsDeclared = variable.Declaration.IsDeclared;
+            IsCreated = variable.IsCreated;
+            IsLocalFunctionCalled = variable.IsLocalFunctionCalled;
+            RawCodeExpression = variable.RawCodeExpression;
         }
     }
 }