Refactor: Remove ILocks.HasLockField and shift locking responsibility into CompositionCode. Simplify constructor builders by eliminating unnecessary ILocks dependency.

NikolayPianikov · NikolayPianikov · commit f60ca98be97e · 2026-04-12T09:37:49.000+03:00
diff --git a/src/Pure.DI.Core/Core/Code/CompositionBuilder.cs b/src/Pure.DI.Core/Core/Code/CompositionBuilder.cs
@@ -153,6 +153,10 @@ public CompositionCode Build(DependencyGraph graph)
             }
         }
         var setupContextMembers = graph.Source.SetupContextMembers;
+        var setupContextMembersToCopy = GetSetupContextMembersToCopy(setupContextMembers);
+        var setupContextArgsToCopy = setupContextArgs
+            .Where(arg => arg.Kind != SetupContextKind.RootArgument)
+            .ToImmutableArray();
 
         var totalDisposablesCount = 0;
         var disposablesCount = 0;
@@ -180,6 +184,17 @@ public CompositionCode Build(DependencyGraph graph)
                 asyncDisposablesCount++;
             }
         }
+
+        var classArgsToStore = varDeclarationTools.Sort(classArgs).Distinct().ToImmutableArray();
+        var isLockRequired = isThreadSafe || HasRootOverrides(graph);
+        var requiresParentScope = singletons.Length > 0
+                                  || classArgsToStore.Length > 0
+                                  || setupContextArgsToCopy.Length > 0
+                                  || setupContextMembersToCopy.Length > 0
+                                  || isLockRequired
+                                  || totalDisposablesCount > 0;
+        var scopeFactoryName = graph.Source.Hints.ScopeFactoryName;
+        var isFactoryMethod = requiresParentScope && !string.IsNullOrWhiteSpace(scopeFactoryName);
         var composition = new CompositionCode(
             graph,
             new Lines(),
@@ -191,11 +206,66 @@ public CompositionCode Build(DependencyGraph graph)
             isThreadSafe,
             new Lines(),
             singletons,
-            varDeclarationTools.Sort(classArgs).Distinct().ToImmutableArray(),
+            classArgsToStore,
             setupContextArgs.ToImmutableArray(),
-            setupContextMembers);
+            setupContextMembers,
+            setupContextArgsToCopy,
+            setupContextMembersToCopy,
+            scopeFactoryName,
+            isFactoryMethod,
+            requiresParentScope,
+            isLockRequired);
 
         var diagram = classDiagramBuilder.Build(composition);
         return composition with { Diagram = diagram };
     }
+
+    private bool HasRootOverrides(DependencyGraph graph) =>
+        graph.Roots.Any(root => overridesRegistry.GetOverrides(root).Any());
+
+    private static ImmutableArray<string> GetSetupContextMembersToCopy(ImmutableArray<SetupContextMembers> setupContextMembers)
+    {
+        var memberNames = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var setupContext in setupContextMembers)
+        {
+            foreach (var member in setupContext.Members)
+            {
+                switch (member)
+                {
+                    case FieldDeclarationSyntax { Declaration: { } declaration }:
+                        foreach (var variable in declaration.Variables)
+                        {
+                            if (!variable.Identifier.IsKind(SyntaxKind.None))
+                            {
+                                memberNames.Add(variable.Identifier.ValueText);
+                            }
+                        }
+
+                        break;
+
+                    case PropertyDeclarationSyntax property when IsPropertyAssignable(property):
+                        if (!property.Identifier.IsKind(SyntaxKind.None))
+                        {
+                            memberNames.Add(property.Identifier.ValueText);
+                        }
+
+                        break;
+                }
+            }
+        }
+
+        return memberNames.ToImmutableArray();
+    }
+
+    private static bool IsPropertyAssignable(PropertyDeclarationSyntax property)
+    {
+        if (property.ExpressionBody is not null || property.AccessorList is not { } accessorList)
+        {
+            return false;
+        }
+
+        return accessorList.Accessors.Any(accessor =>
+               accessor.Kind() is SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration)
+               || accessorList.Accessors.All(accessor => accessor.Body is null && accessor.ExpressionBody is null);
+    }
 }
diff --git a/src/Pure.DI.Core/Core/Code/ILocks.cs b/src/Pure.DI.Core/Core/Code/ILocks.cs
@@ -2,7 +2,5 @@
 
 interface ILocks
 {
-    bool HasLockField(DependencyGraph dependencyGraph);
-
     void AddLockStatements(bool isStatic, Lines lines, bool isAsync);
-}
+}
diff --git a/src/Pure.DI.Core/Core/Code/Locks.cs b/src/Pure.DI.Core/Core/Code/Locks.cs
@@ -1,11 +1,8 @@
 ﻿// ReSharper disable ClassNeverInstantiated.Global
 namespace Pure.DI.Core.Code;
 
-sealed class Locks(IOverridesRegistry overridesRegistry) : ILocks
+sealed class Locks : ILocks
 {
-    public bool HasLockField(DependencyGraph dependencyGraph) =>
-        dependencyGraph.Roots.Any(root => overridesRegistry.GetOverrides(root).Any());
-
     public void AddLockStatements(bool isStatic, Lines lines, bool isAsync)
     {
         if (isAsync)
@@ -15,4 +12,4 @@ public void AddLockStatements(bool isStatic, Lines lines, bool isAsync)
 
         lines.AppendLine($"lock ({(isStatic ? Names.PerResolveLockFieldName : Names.LockFieldName)})");
     }
-}
+}
diff --git a/src/Pure.DI.Core/Core/Code/Parts/DefaultConstructorBuilder.cs b/src/Pure.DI.Core/Core/Code/Parts/DefaultConstructorBuilder.cs
@@ -3,7 +3,6 @@
 namespace Pure.DI.Core.Code.Parts;
 
 sealed class DefaultConstructorBuilder(
-    ILocks locks,
     IConstructors constructors,
     ICodeNameProvider codeNameProvider)
     : IClassPartBuilder
@@ -12,7 +11,7 @@ sealed class DefaultConstructorBuilder(
 
     public CompositionCode Build(CompositionCode composition)
     {
-        if (!constructors.IsEnabled(composition, ConstructorKind.Default) || !string.IsNullOrWhiteSpace(composition.Source.Source.Hints.ScopeFactoryName))
+        if (!constructors.IsEnabled(composition, ConstructorKind.Default) || composition.IsFactoryMethod)
         {
             return composition;
         }
@@ -38,7 +37,7 @@ public CompositionCode Build(CompositionCode composition)
                 code.AppendLine($"{Names.RootFieldName} = this;");
             }
 
-            if (composition.IsLockRequired(locks))
+            if (composition.IsLockRequired)
             {
                 code.AppendLine(new Line(int.MinValue, "#if NET9_0_OR_GREATER"));
                 code.AppendLine($"{Names.LockFieldName} = new {Names.LockTypeName}();");
diff --git a/src/Pure.DI.Core/Core/Code/Parts/DisposeMethodBuilder.cs b/src/Pure.DI.Core/Core/Code/Parts/DisposeMethodBuilder.cs
@@ -186,7 +186,7 @@ private void AddSyncPart(CompositionCode composition, Lines code, bool isAsync)
     {
         code.AppendLine("int disposeIndex;");
         code.AppendLine("object[] disposables;");
-        var isLockRequired = composition.IsLockRequired(locks);
+        var isLockRequired = composition.IsLockRequired;
         if (isLockRequired)
         {
             locks.AddLockStatements(false, code, isAsync);
@@ -218,4 +218,4 @@ private void AddSyncPart(CompositionCode composition, Lines code, bool isAsync)
             code.AppendLine(BlockFinish);
         }
     }
-}
+}
diff --git a/src/Pure.DI.Core/Core/Code/Parts/FieldsBuilder.cs b/src/Pure.DI.Core/Core/Code/Parts/FieldsBuilder.cs
@@ -5,7 +5,6 @@ namespace Pure.DI.Core.Code.Parts;
 
 sealed class FieldsBuilder(
     ITypeResolver typeResolver,
-    ILocks locks,
     IConstructors constructors)
     : IClassPartBuilder
 {
@@ -18,7 +17,7 @@ public CompositionCode Build(CompositionCode composition)
         var compilation = composition.Compilation;
         var nullable = compilation.Options.NullableContextOptions == NullableContextOptions.Disable ? "" : "?";
         var isAnyConstructorEnabled = constructors.IsEnabled(composition.Source);
-        var hasScopeFactory = isAnyConstructorEnabled && constructors.IsEnabled(composition, ConstructorKind.Scope) && !string.IsNullOrWhiteSpace(composition.Source.Source.Hints.ScopeFactoryName);
+        var hasScopeFactory = isAnyConstructorEnabled && constructors.IsEnabled(composition, ConstructorKind.Scope) && composition.IsFactoryMethod;
         var skipFieldsInit = isAnyConstructorEnabled && !hasScopeFactory;
         if (isAnyConstructorEnabled && composition.Singletons.Length > 0)
         {
@@ -27,7 +26,7 @@ public CompositionCode Build(CompositionCode composition)
             membersCounter++;
         }
 
-        if (composition.IsLockRequired(locks))
+        if (composition.IsLockRequired)
         {
             // _lock field
             code.AppendLine(new Line(int.MinValue, "#if NET9_0_OR_GREATER"));
@@ -73,4 +72,4 @@ public CompositionCode Build(CompositionCode composition)
 
         return composition with { MembersCount = membersCounter };
     }
-}
+}
diff --git a/src/Pure.DI.Core/Core/Code/Parts/ParameterizedConstructorBuilder.cs b/src/Pure.DI.Core/Core/Code/Parts/ParameterizedConstructorBuilder.cs
@@ -5,7 +5,6 @@ namespace Pure.DI.Core.Code.Parts;
 sealed class ParameterizedConstructorBuilder(
     ITypeResolver typeResolver,
     [Tag(typeof(ParameterizedConstructorCommenter))] ICommenter<Unit> constructorCommenter,
-    ILocks locks,
     IConstructors constructors,
     ICodeNameProvider codeNameProvider)
     : IClassPartBuilder
@@ -69,7 +68,7 @@ public CompositionCode Build(CompositionCode composition)
                 code.AppendLine($"{Names.RootFieldName} = this;");
             }
 
-            if (composition.IsLockRequired(locks))
+            if (composition.IsLockRequired)
             {
                 code.AppendLine(new Line(int.MinValue, "#if NET9_0_OR_GREATER"));
                 code.AppendLine($"{Names.LockFieldName} = new {Names.LockTypeName}();");
diff --git a/src/Pure.DI.Core/Core/Code/Parts/ScopeConstructorBuilder.cs b/src/Pure.DI.Core/Core/Code/Parts/ScopeConstructorBuilder.cs
@@ -3,11 +3,7 @@
 // ReSharper disable ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
 namespace Pure.DI.Core.Code.Parts;
 
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-
 sealed class ScopeConstructorBuilder(
-    ILocks locks,
     IConstructors constructors,
     ICodeNameProvider codeNameProvider)
     : IClassPartBuilder
@@ -24,20 +20,13 @@ public CompositionCode Build(CompositionCode composition)
         var code = composition.Code;
         var membersCounter = composition.MembersCount;
         var hints = composition.Source.Source.Hints;
-        var setupContextMembersToCopy = GetSetupContextMembersToCopy(composition);
+        var setupContextMembersToCopy = composition.SetupContextMembersToCopy;
         var classArgs = composition.ClassArgs.GetArgsOfKind(ArgKind.Composition).ToList();
-        var setupContextArgsToCopy = composition.SetupContextArgs
-            .Where(arg => arg.Kind != SetupContextKind.RootArgument)
-            .ToList();
-        var isLockRequired = composition.IsLockRequired(locks);
-        var requiresParentScope = composition.Singletons.Length > 0
-                                  || classArgs.Count > 0
-                                  || setupContextArgsToCopy.Count > 0
-                                  || setupContextMembersToCopy.Count > 0
-                                  || isLockRequired
-                                  || composition.TotalDisposablesCount > 0;
-        var scopeFactoryName = hints.ScopeFactoryName;
-        var isFactoryMethod = requiresParentScope && !string.IsNullOrWhiteSpace(scopeFactoryName);
+        var setupContextArgsToCopy = composition.SetupContextArgsToCopy;
+        var isLockRequired = composition.IsLockRequired;
+        var requiresParentScope = composition.RequiresParentScope;
+        var scopeFactoryName = composition.ScopeFactoryName;
+        var isFactoryMethod = composition.IsFactoryMethod;
         var isCommentsEnabled = hints.IsCommentsEnabled;
         string source, destination;
         if (isFactoryMethod)
@@ -65,7 +54,7 @@ public CompositionCode Build(CompositionCode composition)
 
             source = $"{Names.ParentScopeArgName}.";
             destination = "";
-            var ctorName = isFactoryMethod ? scopeFactoryName : codeNameProvider.GetConstructorName(composition.Source.Source.Name.ClassName);
+            var ctorName = codeNameProvider.GetConstructorName(composition.Source.Source.Name.ClassName);
             code.AppendLine($"internal {ctorName}({composition.Source.Source.Name.ClassName} {Names.ParentScopeArgName})");
         }
 
@@ -138,50 +127,4 @@ public CompositionCode Build(CompositionCode composition)
         membersCounter++;
         return composition with { MembersCount = membersCounter };
     }
-
-    private static IReadOnlyCollection<string> GetSetupContextMembersToCopy(CompositionCode composition)
-    {
-        var memberNames = new HashSet<string>(StringComparer.Ordinal);
-        foreach (var setupContextMembers in composition.SetupContextMembers)
-        {
-            foreach (var member in setupContextMembers.Members)
-            {
-                switch (member)
-                {
-                    case FieldDeclarationSyntax { Declaration: { } declaration }:
-                        foreach (var variable in declaration.Variables)
-                        {
-                            if (!variable.Identifier.IsKind(SyntaxKind.None))
-                            {
-                                memberNames.Add(variable.Identifier.ValueText);
-                            }
-                        }
-
-                        break;
-
-                    case PropertyDeclarationSyntax property when IsPropertyAssignable(property):
-                        if (!property.Identifier.IsKind(SyntaxKind.None))
-                        {
-                            memberNames.Add(property.Identifier.ValueText);
-                        }
-
-                        break;
-                }
-            }
-        }
-
-        return memberNames;
-    }
-
-    private static bool IsPropertyAssignable(PropertyDeclarationSyntax property)
-    {
-        if (property.ExpressionBody is not null || property.AccessorList is not { } accessorList)
-        {
-            return false;
-        }
-
-        return accessorList.Accessors.Any(accessor =>
-               accessor.Kind() is SyntaxKind.SetAccessorDeclaration or SyntaxKind.InitAccessorDeclaration)
-               || accessorList.Accessors.All(accessor => accessor.Body is null && accessor.ExpressionBody is null);
-    }
 }
diff --git a/src/Pure.DI.Core/Core/Models/CompositionCode.cs b/src/Pure.DI.Core/Core/Models/CompositionCode.cs
@@ -14,9 +14,13 @@ record CompositionCode(
     in ImmutableArray<VarDeclaration> ClassArgs,
     in ImmutableArray<SetupContextArg> SetupContextArgs,
     in ImmutableArray<SetupContextMembers> SetupContextMembers,
+    in ImmutableArray<SetupContextArg> SetupContextArgsToCopy,
+    in ImmutableArray<string> SetupContextMembersToCopy,
+    string ScopeFactoryName,
+    bool IsFactoryMethod,
+    bool RequiresParentScope,
+    bool IsLockRequired,
     int MembersCount = 0)
 {
     public Compilation Compilation => Source.Source.SemanticModel.Compilation;
-
-    public bool IsLockRequired(ILocks locks) => IsThreadSafe || locks.HasLockField(Source);
 }

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,5 @@`
`2`	`2`
`3`	`3`	`interface ILocks`
`4`	`4`	`{`
`5`		`- bool HasLockField(DependencyGraph dependencyGraph);`
`6`		`-`
`7`	`5`	`void AddLockStatements(bool isStatic, Lines lines, bool isAsync);`
`8`		`-}`
	`6`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,8 @@`
`1`	`1`	`// ReSharper disable ClassNeverInstantiated.Global`
`2`	`2`	`namespace Pure.DI.Core.Code;`
`3`	`3`
`4`		`-sealed class Locks(IOverridesRegistry overridesRegistry) : ILocks`
	`4`	`+sealed class Locks : ILocks`
`5`	`5`	`{`
`6`		`- public bool HasLockField(DependencyGraph dependencyGraph) =>`
`7`		`- dependencyGraph.Roots.Any(root => overridesRegistry.GetOverrides(root).Any());`
`8`		`-`
`9`	`6`	`public void AddLockStatements(bool isStatic, Lines lines, bool isAsync)`
`10`	`7`	`{`
`11`	`8`	`if (isAsync)`
`@@ -15,4 +12,4 @@ public void AddLockStatements(bool isStatic, Lines lines, bool isAsync)`
`15`	`12`
`16`	`13`	`lines.AppendLine($"lock ({(isStatic ? Names.PerResolveLockFieldName : Names.LockFieldName)})");`
`17`	`14`	`}`
`18`		`-}`
	`15`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,6 @@`
`3`	`3`	`namespace Pure.DI.Core.Code.Parts;`
`4`	`4`
`5`	`5`	`sealed class DefaultConstructorBuilder(`
`6`		`- ILocks locks,`
`7`	`6`	`IConstructors constructors,`
`8`	`7`	`ICodeNameProvider codeNameProvider)`
`9`	`8`	`: IClassPartBuilder`
`@@ -12,7 +11,7 @@ sealed class DefaultConstructorBuilder(`
`12`	`11`
`13`	`12`	`public CompositionCode Build(CompositionCode composition)`
`14`	`13`	`{`
`15`		`- if (!constructors.IsEnabled(composition, ConstructorKind.Default) \|\| !string.IsNullOrWhiteSpace(composition.Source.Source.Hints.ScopeFactoryName))`
	`14`	`+ if (!constructors.IsEnabled(composition, ConstructorKind.Default) \|\| composition.IsFactoryMethod)`
`16`	`15`	`{`
`17`	`16`	`return composition;`
`18`	`17`	`}`
`@@ -38,7 +37,7 @@ public CompositionCode Build(CompositionCode composition)`
`38`	`37`	`code.AppendLine($"{Names.RootFieldName} = this;");`
`39`	`38`	`}`
`40`	`39`
`41`		`- if (composition.IsLockRequired(locks))`
	`40`	`+ if (composition.IsLockRequired)`
`42`	`41`	`{`
`43`	`42`	`code.AppendLine(new Line(int.MinValue, "#if NET9_0_OR_GREATER"));`
`44`	`43`	`code.AppendLine($"{Names.LockFieldName} = new {Names.LockTypeName}();");`
Original file line number	Diff line number	Diff line change
`@@ -186,7 +186,7 @@ private void AddSyncPart(CompositionCode composition, Lines code, bool isAsync)`
`186`	`186`	`{`
`187`	`187`	`code.AppendLine("int disposeIndex;");`
`188`	`188`	`code.AppendLine("object[] disposables;");`
`189`		`- var isLockRequired = composition.IsLockRequired(locks);`
	`189`	`+ var isLockRequired = composition.IsLockRequired;`
`190`	`190`	`if (isLockRequired)`
`191`	`191`	`{`
`192`	`192`	`locks.AddLockStatements(false, code, isAsync);`
`@@ -218,4 +218,4 @@ private void AddSyncPart(CompositionCode composition, Lines code, bool isAsync)`
`218`	`218`	`code.AppendLine(BlockFinish);`
`219`	`219`	`}`
`220`	`220`	`}`
`221`		`-}`
	`221`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,6 @@ namespace Pure.DI.Core.Code.Parts;`
`5`	`5`
`6`	`6`	`sealed class FieldsBuilder(`
`7`	`7`	`ITypeResolver typeResolver,`
`8`		`- ILocks locks,`
`9`	`8`	`IConstructors constructors)`
`10`	`9`	`: IClassPartBuilder`
`11`	`10`	`{`
`@@ -18,7 +17,7 @@ public CompositionCode Build(CompositionCode composition)`
`18`	`17`	`var compilation = composition.Compilation;`
`19`	`18`	`var nullable = compilation.Options.NullableContextOptions == NullableContextOptions.Disable ? "" : "?";`
`20`	`19`	`var isAnyConstructorEnabled = constructors.IsEnabled(composition.Source);`
`21`		`- var hasScopeFactory = isAnyConstructorEnabled && constructors.IsEnabled(composition, ConstructorKind.Scope) && !string.IsNullOrWhiteSpace(composition.Source.Source.Hints.ScopeFactoryName);`
	`20`	`+ var hasScopeFactory = isAnyConstructorEnabled && constructors.IsEnabled(composition, ConstructorKind.Scope) && composition.IsFactoryMethod;`
`22`	`21`	`var skipFieldsInit = isAnyConstructorEnabled && !hasScopeFactory;`
`23`	`22`	`if (isAnyConstructorEnabled && composition.Singletons.Length > 0)`
`24`	`23`	`{`
`@@ -27,7 +26,7 @@ public CompositionCode Build(CompositionCode composition)`
`27`	`26`	`membersCounter++;`
`28`	`27`	`}`
`29`	`28`
`30`		`- if (composition.IsLockRequired(locks))`
	`29`	`+ if (composition.IsLockRequired)`
`31`	`30`	`{`
`32`	`31`	`// _lock field`
`33`	`32`	`code.AppendLine(new Line(int.MinValue, "#if NET9_0_OR_GREATER"));`
`@@ -73,4 +72,4 @@ public CompositionCode Build(CompositionCode composition)`
`73`	`72`
`74`	`73`	`return composition with { MembersCount = membersCounter };`
`75`	`74`	`}`
`76`		`-}`
	`75`	`+}`