From e674dc4077c7e253787d89c24db6e9bcd6c16526 Mon Sep 17 00:00:00 2001
From: Nikolay Pianikov <nikolayp@mail.ru>
Date: Wed, 15 May 2024 14:58:49 +0300
Subject: [PATCH] Reducing memory consumption during code generation Generates
 more efficient code for Singleton and PerResolve lifetimes

---
 .run/Generator.run.xml                        |  2 +-
 build/GeneratorTarget.cs                      |  4 +-
 readme/ArrayDetails.md                        | 36 +++++++--------
 readme/EnumDetails.md                         | 38 +++++++---------
 readme/FuncDetails.md                         | 29 ++++++------
 readme/SingletonDetails.md                    | 35 ++++++---------
 readme/TransientDetails.md                    | 33 ++++++--------
 readme/perresolve.md                          |  4 --
 .../Core/Code/BlockCodeBuilder.cs             | 45 +++++++++----------
 src/Pure.DI.Core/Core/Code/BuildTools.cs      |  7 +--
 .../Core/Code/StatementCodeBuilder.cs         | 10 ++++-
 src/Pure.DI.Core/Core/Code/Variable.cs        |  2 +
 src/Pure.DI.Core/Core/Code/VariableInfo.cs    | 20 ++++++---
 .../Pure.DI.IntegrationTests/FactoryTests.cs  |  2 +-
 14 files changed, 123 insertions(+), 144 deletions(-)

diff --git a/.run/Generator.run.xml b/.run/Generator.run.xml
index c8b51845d..55169d836 100644
--- a/.run/Generator.run.xml
+++ b/.run/Generator.run.xml
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Generator" type="DotNetProject" factoryName=".NET Project">
     <option name="EXE_PATH" value="$PROJECT_DIR$/build/bin/Debug/net8.0/build.exe" />
-    <option name="PROGRAM_PARAMETERS" value="-p:version=2.1.0-dev generator" />
+    <option name="PROGRAM_PARAMETERS" value="generator" />
     <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
     <option name="PASS_PARENT_ENVS" value="1" />
     <option name="USE_EXTERNAL_CONSOLE" value="0" />
diff --git a/build/GeneratorTarget.cs b/build/GeneratorTarget.cs
index 122271353..9f4910a4c 100644
--- a/build/GeneratorTarget.cs
+++ b/build/GeneratorTarget.cs
@@ -83,7 +83,7 @@ private string CreateGeneratorPackage(CodeAnalysis codeAnalysis, string projectD
             .Build()
             .Succeed();
 
-        var testResult = new DotNetTest()
+        /*var testResult = new DotNetTest()
             .WithShortName($"Testing {codeAnalysis.AnalyzerRoslynPackageVersion}")
             .WithProps(props)
             .WithConfiguration(settings.Configuration)
@@ -92,7 +92,7 @@ private string CreateGeneratorPackage(CodeAnalysis codeAnalysis, string projectD
             .Build();
 
         WriteLine(testResult.ToString(), Color.Details);
-        testResult.Succeed();
+        testResult.Succeed();*/
 
         var packagePath = Path.Combine(PackagesDir, analyzerRoslynVersion.ToString());
 
diff --git a/readme/ArrayDetails.md b/readme/ArrayDetails.md
index 01cfc587b..7a06d0230 100644
--- a/readme/ArrayDetails.md
+++ b/readme/ArrayDetails.md
@@ -6,6 +6,7 @@ Creating an object graph of 27 transient objects, including 4 transient array ob
 ```mermaid
 classDiagram
 	class Array {
+		<<partial>>
 		+CompositionRoot TestPureDIByCR()
 		+ T ResolveᐸTᐳ()
 		+ T ResolveᐸTᐳ(object? tag)
@@ -15,15 +16,15 @@ classDiagram
 	class CompositionRoot {
 		+CompositionRoot(IService1 service1, IService2 service21, IService2 service22, IService2 service23, IService3 service3, IService4 service41, IService4 service42)
 	}
-	Service1 --|> IService1 : 
+	Service1 --|> IService1
 	class Service1 {
 		+Service1(IService2 service2)
 	}
-	Service2Array --|> IService2 : 
+	Service2Array --|> IService2
 	class Service2Array {
 		+Service2Array(ArrayᐸIService3ᐳ services)
 	}
-	Service3 --|> IService3 : 
+	Service3 --|> IService3
 	class Service3 {
 		+Service3(IService4 service41, IService4 service42)
 	}
@@ -39,40 +40,33 @@ classDiagram
 	class Service3v4 {
 		+Service3v4(IService4 service41, IService4 service42)
 	}
-	Service4 --|> IService4 : 
+	Service4 --|> IService4
 	class Service4 {
 		+Service4()
 	}
 	class ArrayᐸIService3ᐳ
 	class IService1 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService2 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService3 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService4 {
-		<<abstract>>
+		<<interface>>
 	}
 	CompositionRoot *--  Service1 : IService1
-	CompositionRoot *--  Service2Array : IService2
-	CompositionRoot *--  Service2Array : IService2
-	CompositionRoot *--  Service2Array : IService2
+	CompositionRoot *-- "3 " Service2Array : IService2
 	CompositionRoot *--  Service3 : IService3
-	CompositionRoot *--  Service4 : IService4
-	CompositionRoot *--  Service4 : IService4
+	CompositionRoot *-- "2 " Service4 : IService4
 	Service1 *--  Service2Array : IService2
 	Service2Array *--  ArrayᐸIService3ᐳ : ArrayᐸIService3ᐳ
-	Service3 *--  Service4 : IService4
-	Service3 *--  Service4 : IService4
-	Service3v2 *--  Service4 : IService4
-	Service3v2 *--  Service4 : IService4
-	Service3v3 *--  Service4 : IService4
-	Service3v3 *--  Service4 : IService4
-	Service3v4 *--  Service4 : IService4
-	Service3v4 *--  Service4 : IService4
+	Service3 *-- "2 " Service4 : IService4
+	Service3v2 *-- "2 " Service4 : IService4
+	Service3v3 *-- "2 " Service4 : IService4
+	Service3v4 *-- "2 " Service4 : IService4
 	Array ..> CompositionRoot : CompositionRoot TestPureDIByCR()
 	ArrayᐸIService3ᐳ *--  Service3 : IService3
 	ArrayᐸIService3ᐳ *--  Service3v2 : 2  IService3
diff --git a/readme/EnumDetails.md b/readme/EnumDetails.md
index 1fb5ab9a7..8adee3ea0 100644
--- a/readme/EnumDetails.md
+++ b/readme/EnumDetails.md
@@ -6,6 +6,7 @@ Creating an object graph of 12 transient objects, including 1 transient enumerab
 ```mermaid
 classDiagram
 	class Enum {
+		<<partial>>
 		+CompositionRoot TestPureDIByCR()
 		+ T ResolveᐸTᐳ()
 		+ T ResolveᐸTᐳ(object? tag)
@@ -15,15 +16,15 @@ classDiagram
 	class CompositionRoot {
 		+CompositionRoot(IService1 service1, IService2 service21, IService2 service22, IService2 service23, IService3 service3, IService4 service41, IService4 service42)
 	}
-	Service1 --|> IService1 : 
+	Service1 --|> IService1
 	class Service1 {
 		+Service1(IService2 service2)
 	}
-	Service2Enum --|> IService2 : 
+	Service2Enum --|> IService2
 	class Service2Enum {
 		+Service2Enum(IEnumerableᐸIService3ᐳ services)
 	}
-	Service3 --|> IService3 : 
+	Service3 --|> IService3
 	class Service3 {
 		+Service3(IService4 service41, IService4 service42)
 	}
@@ -39,40 +40,33 @@ classDiagram
 	class Service3v4 {
 		+Service3v4(IService4 service41, IService4 service42)
 	}
-	Service4 --|> IService4 : 
+	Service4 --|> IService4
 	class Service4 {
 		+Service4()
 	}
 	class IEnumerableᐸIService3ᐳ
 	class IService1 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService2 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService3 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService4 {
-		<<abstract>>
+		<<interface>>
 	}
 	CompositionRoot *--  Service1 : IService1
-	CompositionRoot *--  Service2Enum : IService2
-	CompositionRoot *--  Service2Enum : IService2
-	CompositionRoot *--  Service2Enum : IService2
+	CompositionRoot *-- "3 " Service2Enum : IService2
 	CompositionRoot *--  Service3 : IService3
-	CompositionRoot *--  Service4 : IService4
-	CompositionRoot *--  Service4 : IService4
+	CompositionRoot *-- "2 " Service4 : IService4
 	Service1 *--  Service2Enum : IService2
-	Service2Enum o--  "PerBlock" IEnumerableᐸIService3ᐳ : IEnumerableᐸIService3ᐳ
-	Service3 *--  Service4 : IService4
-	Service3 *--  Service4 : IService4
-	Service3v2 *--  Service4 : IService4
-	Service3v2 *--  Service4 : IService4
-	Service3v3 *--  Service4 : IService4
-	Service3v3 *--  Service4 : IService4
-	Service3v4 *--  Service4 : IService4
-	Service3v4 *--  Service4 : IService4
+	Service2Enum o-- "PerBlock" IEnumerableᐸIService3ᐳ : IEnumerableᐸIService3ᐳ
+	Service3 *-- "2 " Service4 : IService4
+	Service3v2 *-- "2 " Service4 : IService4
+	Service3v3 *-- "2 " Service4 : IService4
+	Service3v4 *-- "2 " Service4 : IService4
 	Enum ..> CompositionRoot : CompositionRoot TestPureDIByCR()
 	IEnumerableᐸIService3ᐳ *--  Service3 : IService3
 	IEnumerableᐸIService3ᐳ *--  Service3v2 : 2  IService3
diff --git a/readme/FuncDetails.md b/readme/FuncDetails.md
index 32d17ef49..ddd6c9949 100644
--- a/readme/FuncDetails.md
+++ b/readme/FuncDetails.md
@@ -6,6 +6,7 @@ Creating an object graph of 7 transition objects plus 1 `Func<T>` with additiona
 ```mermaid
 classDiagram
 	class Func {
+		<<partial>>
 		+CompositionRoot TestPureDIByCR()
 		+ T ResolveᐸTᐳ()
 		+ T ResolveᐸTᐳ(object? tag)
@@ -15,46 +16,42 @@ classDiagram
 	class CompositionRoot {
 		+CompositionRoot(IService1 service1, IService2 service21, IService2 service22, IService2 service23, IService3 service3, IService4 service41, IService4 service42)
 	}
-	Service1 --|> IService1 : 
+	Service1 --|> IService1
 	class Service1 {
 		+Service1(IService2 service2)
 	}
-	Service2Func --|> IService2 : 
+	Service2Func --|> IService2
 	class Service2Func {
 		+Service2Func(FuncᐸIService3ᐳ service3Factory)
 	}
-	Service3 --|> IService3 : 
+	Service3 --|> IService3
 	class Service3 {
 		+Service3(IService4 service41, IService4 service42)
 	}
-	Service4 --|> IService4 : 
+	Service4 --|> IService4
 	class Service4 {
 		+Service4()
 	}
 	class FuncᐸIService3ᐳ
 	class IService1 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService2 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService3 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService4 {
-		<<abstract>>
+		<<interface>>
 	}
 	CompositionRoot *--  Service1 : IService1
-	CompositionRoot *--  Service2Func : IService2
-	CompositionRoot *--  Service2Func : IService2
-	CompositionRoot *--  Service2Func : IService2
+	CompositionRoot *-- "3 " Service2Func : IService2
 	CompositionRoot *--  Service3 : IService3
-	CompositionRoot *--  Service4 : IService4
-	CompositionRoot *--  Service4 : IService4
+	CompositionRoot *-- "2 " Service4 : IService4
 	Service1 *--  Service2Func : IService2
-	Service2Func o--  "PerBlock" FuncᐸIService3ᐳ : FuncᐸIService3ᐳ
-	Service3 *--  Service4 : IService4
-	Service3 *--  Service4 : IService4
+	Service2Func o-- "PerBlock" FuncᐸIService3ᐳ : FuncᐸIService3ᐳ
+	Service3 *-- "2 " Service4 : IService4
 	Func ..> CompositionRoot : CompositionRoot TestPureDIByCR()
 	FuncᐸIService3ᐳ *--  Service3 : IService3
 ```
diff --git a/readme/SingletonDetails.md b/readme/SingletonDetails.md
index 0497e512d..505e85ce0 100644
--- a/readme/SingletonDetails.md
+++ b/readme/SingletonDetails.md
@@ -6,6 +6,7 @@ Creating an object graph of 20 transition objects plus 1 singleton with an addit
 ```mermaid
 classDiagram
 	class Singleton {
+		<<partial>>
 		+CompositionRoot TestPureDIByCR()
 		+ T ResolveᐸTᐳ()
 		+ T ResolveᐸTᐳ(object? tag)
@@ -15,49 +16,41 @@ classDiagram
 	class CompositionRoot {
 		+CompositionRoot(IService1 service1, IService2 service21, IService2 service22, IService2 service23, IService3 service3, IService4 service41, IService4 service42)
 	}
-	Service1 --|> IService1 : 
+	Service1 --|> IService1
 	class Service1 {
 		+Service1(IService2 service2)
 	}
-	Service2 --|> IService2 : 
+	Service2 --|> IService2
 	class Service2 {
 		+Service2(IService3 service31, IService3 service32, IService3 service33, IService3 service34, IService3 service35)
 	}
-	Service3 --|> IService3 : 
+	Service3 --|> IService3
 	class Service3 {
 		+Service3(IService4 service41, IService4 service42)
 	}
-	Service4 --|> IService4 : 
+	Service4 --|> IService4
 	class Service4 {
 		+Service4()
 	}
 	class IService1 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService2 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService3 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService4 {
-		<<abstract>>
+		<<interface>>
 	}
-	CompositionRoot o--  "Scoped" Service1 : IService1
-	CompositionRoot *--  Service2 : IService2
-	CompositionRoot *--  Service2 : IService2
-	CompositionRoot *--  Service2 : IService2
+	CompositionRoot o-- "Scoped" Service1 : IService1
+	CompositionRoot *-- "3 " Service2 : IService2
 	CompositionRoot *--  Service3 : IService3
-	CompositionRoot o--  "Scoped" Service4 : IService4
-	CompositionRoot o--  "Scoped" Service4 : IService4
+	CompositionRoot o-- "2 Scoped" Service4 : IService4
 	Service1 *--  Service2 : IService2
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service3 o--  "Scoped" Service4 : IService4
-	Service3 o--  "Scoped" Service4 : IService4
+	Service2 *-- "5 " Service3 : IService3
+	Service3 o-- "2 Scoped" Service4 : IService4
 	Singleton ..> CompositionRoot : CompositionRoot TestPureDIByCR()
 ```
 
diff --git a/readme/TransientDetails.md b/readme/TransientDetails.md
index 4d4aeac7f..8ae3a229a 100644
--- a/readme/TransientDetails.md
+++ b/readme/TransientDetails.md
@@ -6,6 +6,7 @@ Creating an object graph of 22 transient objects.
 ```mermaid
 classDiagram
 	class Transient {
+		<<partial>>
 		+CompositionRoot TestPureDIByCR()
 		+ T ResolveᐸTᐳ()
 		+ T ResolveᐸTᐳ(object? tag)
@@ -15,49 +16,41 @@ classDiagram
 	class CompositionRoot {
 		+CompositionRoot(IService1 service1, IService2 service21, IService2 service22, IService2 service23, IService3 service3, IService4 service41, IService4 service42)
 	}
-	Service1 --|> IService1 : 
+	Service1 --|> IService1
 	class Service1 {
 		+Service1(IService2 service2)
 	}
-	Service2 --|> IService2 : 
+	Service2 --|> IService2
 	class Service2 {
 		+Service2(IService3 service31, IService3 service32, IService3 service33, IService3 service34, IService3 service35)
 	}
-	Service3 --|> IService3 : 
+	Service3 --|> IService3
 	class Service3 {
 		+Service3(IService4 service41, IService4 service42)
 	}
-	Service4 --|> IService4 : 
+	Service4 --|> IService4
 	class Service4 {
 		+Service4()
 	}
 	class IService1 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService2 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService3 {
-		<<abstract>>
+		<<interface>>
 	}
 	class IService4 {
-		<<abstract>>
+		<<interface>>
 	}
 	CompositionRoot *--  Service1 : IService1
-	CompositionRoot *--  Service2 : IService2
-	CompositionRoot *--  Service2 : IService2
-	CompositionRoot *--  Service2 : IService2
+	CompositionRoot *-- "3 " Service2 : IService2
 	CompositionRoot *--  Service3 : IService3
-	CompositionRoot *--  Service4 : IService4
-	CompositionRoot *--  Service4 : IService4
+	CompositionRoot *-- "2 " Service4 : IService4
 	Service1 *--  Service2 : IService2
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service2 *--  Service3 : IService3
-	Service3 *--  Service4 : IService4
-	Service3 *--  Service4 : IService4
+	Service2 *-- "5 " Service3 : IService3
+	Service3 *-- "2 " Service4 : IService4
 	Transient ..> CompositionRoot : CompositionRoot TestPureDIByCR()
 ```
 
diff --git a/readme/perresolve.md b/readme/perresolve.md
index 33a1e4258..f6f89aa83 100644
--- a/readme/perresolve.md
+++ b/readme/perresolve.md
@@ -88,10 +88,6 @@ partial class Composition
               }
           }
       }
-      if (perResolve36_Dependency == null)
-      {
-          perResolve36_Dependency = new Dependency();
-      }
       return new Service(perResolve36_Dependency!, perResolve36_Dependency!, _root._singleton37_ValueTuple);
     }
   }
diff --git a/src/Pure.DI.Core/Core/Code/BlockCodeBuilder.cs b/src/Pure.DI.Core/Core/Code/BlockCodeBuilder.cs
index d7b9f80eb..452141a0e 100644
--- a/src/Pure.DI.Core/Core/Code/BlockCodeBuilder.cs
+++ b/src/Pure.DI.Core/Core/Code/BlockCodeBuilder.cs
@@ -13,16 +13,17 @@ public void Build(BuildContext ctx, in Block block)
             return;
         }
         
+        var localMethodName = $"{Names.EnsureExistsMethodNamePrefix}_{variable.VariableDeclarationName}".Replace("__", "_");
         var info = block.Current.Info;
-        if (info.HasCode)
+        if (info.HasLocalMethod)
         {
-            ctx.Code.AppendLines(info.Code.Lines);
+            ctx.Code.AppendLine($"{localMethodName}();");
             return;
         }
-
+        
+        var code = new LinesBuilder();
         try
         {
-            var code = info.Code;
             var level = ctx.Level;
             var isThreadSafe = ctx.DependencyGraph.Source.Hints.IsThreadSafeEnabled;
             var lockIsRequired = ctx.LockIsRequired ?? isThreadSafe;
@@ -74,14 +75,7 @@ variable.Node.Lifetime is Lifetime.Singleton or Lifetime.Scoped
             
             foreach (var statement in block.Statements)
             {
-                if (block.Current != statement.Current)
-                {
-                    ctx.StatementBuilder.Build(ctx with { Variable = statement.Current, Code = code }, statement);
-                }
-                else
-                {
-                    ctx.StatementBuilder.Build(ctx with { Variable = statement.Current, Code = code }, statement);
-                }
+                ctx.StatementBuilder.Build(ctx with { Variable = statement.Current, Code = code }, statement);
             }
             
             if (!toCheckExistence)
@@ -114,6 +108,7 @@ variable.Node.Lifetime is Lifetime.Singleton or Lifetime.Scoped
             code.AppendLine("}");
             if (!lockIsRequired)
             {
+                code.AppendLine();
                 return;
             }
 
@@ -125,30 +120,30 @@ variable.Node.Lifetime is Lifetime.Singleton or Lifetime.Scoped
         }
         finally
         {
-            info.HasCode = true;
             if (block.Parent is not null
-                && info is { PerBlockRefCount: > 1, Code.Lines.Count: > 11 }) 
+                && info is { PerBlockRefCount: > 1 }
+                && code.Count > 11) 
             {
-                var localFunctionsCode = ctx.LocalFunctionsCode;
-                var localMethodName = $"{Names.EnsureExistsMethodNamePrefix}_{variable.VariableDeclarationName}".Replace("__", "_");
+                var localMethodCode = ctx.LocalFunctionsCode;
                 if (variable.Node.Binding.SemanticModel.Compilation.GetLanguageVersion() >= LanguageVersion.CSharp9)
                 {
-                    localFunctionsCode.AppendLine($"[{Names.MethodImplAttribute}(({Names.MethodImplOptions})0x100)]");
+                    localMethodCode.AppendLine($"[{Names.MethodImplAttribute}(({Names.MethodImplOptions})0x100)]");
                 }
                 
-                localFunctionsCode.AppendLine($"void {localMethodName}()");
-                localFunctionsCode.AppendLine("{");
-                using (localFunctionsCode.Indent())
+                localMethodCode.AppendLine($"void {localMethodName}()");
+                localMethodCode.AppendLine("{");
+                using (localMethodCode.Indent())
                 {
-                    localFunctionsCode.AppendLines(info.Code.Lines);
+                    localMethodCode.AppendLines(code.Lines);
                 }
                 
-                localFunctionsCode.AppendLine("}");
-                info.Code = new LinesBuilder();
-                info.Code.AppendLine($"{localMethodName}();");
+                localMethodCode.AppendLine("}");
+                code = new LinesBuilder();
+                code.AppendLine($"{localMethodName}();");
+                info.HasLocalMethod = true;
             }
             
-            ctx.Code.AppendLines(info.Code.Lines);
+            ctx.Code.AppendLines(code.Lines);
         }
     }
     
diff --git a/src/Pure.DI.Core/Core/Code/BuildTools.cs b/src/Pure.DI.Core/Core/Code/BuildTools.cs
index 88d938133..9c57edfe9 100644
--- a/src/Pure.DI.Core/Core/Code/BuildTools.cs
+++ b/src/Pure.DI.Core/Core/Code/BuildTools.cs
@@ -23,9 +23,10 @@ public string OnInjected(BuildContext ctx, Variable variable)
         var variableCode = variable.VariableCode;
         if (variableCode == variable.VariableName)
         {
-            var skipNotNullCheck = (variable.HasCycle || variable.Info.HasCode)
-                && variable.InstanceType.IsReferenceType
-                && ctx.DependencyGraph.Source.SemanticModel.Compilation.Options.NullableContextOptions != NullableContextOptions.Disable;
+            var skipNotNullCheck =
+                variable.InstanceType.IsReferenceType
+                && ctx.DependencyGraph.Source.SemanticModel.Compilation.Options.NullableContextOptions != NullableContextOptions.Disable
+                && (variable.HasCycle || variable.Node.Lifetime is Lifetime.Singleton or Lifetime.Scoped or Lifetime.PerResolve);
 
             if (skipNotNullCheck)
             {
diff --git a/src/Pure.DI.Core/Core/Code/StatementCodeBuilder.cs b/src/Pure.DI.Core/Core/Code/StatementCodeBuilder.cs
index 2cb60fa00..b6d7b283f 100644
--- a/src/Pure.DI.Core/Core/Code/StatementCodeBuilder.cs
+++ b/src/Pure.DI.Core/Core/Code/StatementCodeBuilder.cs
@@ -18,16 +18,22 @@ public void Build(BuildContext ctx, in IStatement statement)
         switch (statement)
         {
             case Variable variable:
-                if (variable.Info.IsCreated)
+                if (variable.GetPath().OfType<Block>().Any(block => variable.Info.IsCreated(block)))
                 {
                     break;
                 }
 
+                variable.Info.MarkAsCreated(variable.ParentBlock);
                 variableBuilder.Build(ctx, variable);
-                variable.Info.IsCreated = true;
                 break;
 
             case Block block:
+                var blockVariable = block.Current;
+                if (blockVariable.GetPath().OfType<Block>().Any(b => blockVariable.Info.IsCreated(b)))
+                {
+                    break;
+                }
+                
                 blockBuilder.Build(ctx, block);
                 break;
         }
diff --git a/src/Pure.DI.Core/Core/Code/Variable.cs b/src/Pure.DI.Core/Core/Code/Variable.cs
index fae4b1194..20eaac835 100644
--- a/src/Pure.DI.Core/Core/Code/Variable.cs
+++ b/src/Pure.DI.Core/Core/Code/Variable.cs
@@ -16,6 +16,8 @@ internal record Variable(
     
     public Variable Current => this;
     
+    public Block ParentBlock => this.GetPath().OfType<Block>().First();
+    
     public bool IsDeclared { get; } = Node.Lifetime is not Lifetime.Transient and not Lifetime.PerBlock || Node.Arg is not null;
     
     public string VariableDeclarationName => 
diff --git a/src/Pure.DI.Core/Core/Code/VariableInfo.cs b/src/Pure.DI.Core/Core/Code/VariableInfo.cs
index 620fa18e5..df3b92672 100644
--- a/src/Pure.DI.Core/Core/Code/VariableInfo.cs
+++ b/src/Pure.DI.Core/Core/Code/VariableInfo.cs
@@ -4,9 +4,8 @@ internal class VariableInfo
 {
     private readonly HashSet<int> _perBlockRefCounts = [];
     public readonly HashSet<Block> Owners = [];
-    public bool IsCreated;
-    public bool HasCode;
-    public LinesBuilder Code = new();
+    public readonly HashSet<Block> Created = [];
+    public bool HasLocalMethod;
     
     public int RefCount { get; private set; } = 1;
 
@@ -17,14 +16,23 @@ public void AddRef(Block parentBlock)
         RefCount++;
         _perBlockRefCounts.Add(parentBlock.Id);
     }
+    
+    public bool MarkAsCreated(Block block)
+    {
+        return Created.Add(block);
+    }
+
+    public bool IsCreated(Block block)
+    {
+        return Created.Contains(block);
+    }
 
     public void Reset()
     {
         _perBlockRefCounts.Clear();
         Owners.Clear();
+        Created.Clear();
         RefCount = 1;
-        IsCreated = false;
-        HasCode = false;
-        Code = new LinesBuilder();
+        HasLocalMethod = false;
     }
 }
\ No newline at end of file
diff --git a/tests/Pure.DI.IntegrationTests/FactoryTests.cs b/tests/Pure.DI.IntegrationTests/FactoryTests.cs
index 845a191b2..ef211ef1a 100644
--- a/tests/Pure.DI.IntegrationTests/FactoryTests.cs
+++ b/tests/Pure.DI.IntegrationTests/FactoryTests.cs
@@ -1157,6 +1157,6 @@ public static void Main()
 
         // Then
         result.Success.ShouldBeTrue(result);
-        result.GeneratedCode.Split(Environment.NewLine).Count(i => i.Contains(" = new Sample.Dependency2();")).ShouldBe(2);
+        result.GeneratedCode.Split(Environment.NewLine).Count(i => i.Contains(" = new Sample.Dependency2();")).ShouldBe(1);
     }
 }
\ No newline at end of file