Improved performance

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

@@ -29,7 +29,7 @@ public Block Build(
                 cancellationToken.ThrowIfCancellationRequested();
                 if (counter++ > Const.MaxIterationsCount)
                 {
-                    throw new CompileErrorException("Cyclic dependency has been found.", rootNode.Binding.Source.GetLocation(), LogId.ErrorCyclicDependency);
+                    throw new CompileErrorException($"The composition is too large. Stopped on the #{counter} instance.", rootNode.Binding.Source.GetLocation(), LogId.ErrorInvalidMetadata);
                 }
 
                 switch (currentStatement)

src/Pure.DI.Core/Core/CodeBuilder.cs

@@ -55,14 +55,10 @@ public Unit Build(MdSetup setup)
         composition = classBuilder.Build(composition);
 
         cancellationToken.ThrowIfCancellationRequested();
-        var code = new StringBuilder(composition.Code.Sum(i => i.Length + 2));
-        foreach (var line in composition.Code)
-        {
-            code.AppendLine(line);
-        }
-
+        var size = composition.Code.SaveToArray(Encoding.UTF8, out var buffer);
+
         cancellationToken.ThrowIfCancellationRequested();
-        sources.AddSource($"{setup.Name.FullName}.g.cs", SourceText.From(code.ToString(), Encoding.UTF8));
+        sources.AddSource($"{setup.Name.FullName}.g.cs", SourceText.From(buffer, size, Encoding.UTF8, SourceHashAlgorithm.Sha1, false, true));
         return Unit.Shared;
     }
 }

src/Pure.DI.Core/Core/Const.cs

@@ -2,5 +2,5 @@
 
 public static class Const
 {
-    public const int MaxIterationsCount = 0xffff;
+    public const int MaxIterationsCount = 0x2FFFF;
 }

src/Pure.DI.Core/Core/DependencyGraphBuilder.cs

@@ -75,7 +75,7 @@ public IEnumerable<DependencyNode> TryBuild(
             cancellationToken.ThrowIfCancellationRequested();
             if (counter++ > Const.MaxIterationsCount)
             {
-                throw new CompileErrorException("Cyclic dependency has been found.", setup.Source.GetLocation(), LogId.ErrorCyclicDependency);
+                throw new CompileErrorException($"The composition is too large. Stopped on the #{counter} dependency.", setup.Source.GetLocation(), LogId.ErrorInvalidMetadata);
             }
 
             var targetNode = node.Node;

src/Pure.DI.Core/Core/LinesBuilder.cs

@@ -2,6 +2,8 @@
 // ReSharper disable ReturnTypeCanBeEnumerable.Global
 namespace Pure.DI.Core;
 
+using System.Buffers;
+
 internal sealed class LinesBuilder: IEnumerable<string>
 {
     private static readonly string[] Indents = new string[64]; 
@@ -87,6 +89,31 @@ public IEnumerator<string> GetEnumerator()
         return _lines.Select(i => $"{GetIndent(i.Indent)}{i.Text}").GetEnumerator();
     }
 
+    public int SaveToArray(Encoding encoding, out byte[] buffer)
+    {
+        var charCount = 0;
+        var newLine = Environment.NewLine;
+        foreach (var line in _lines)
+        {
+            charCount += GetIndent(line.Indent).Length;
+            charCount += line.Text.Length;
+            charCount += newLine.Length;
+        }
+
+        var size = encoding.GetMaxByteCount(charCount);
+        buffer = ArrayPool<byte>.Shared.Rent(size);
+        var position = 0;
+        foreach (var line in _lines)
+        {
+            var indent = GetIndent(line.Indent);
+            position += encoding.GetBytes(indent, 0, indent.Length, buffer, position);
+            position += encoding.GetBytes(line.Text, 0, line.Text.Length, buffer, position);
+            position += encoding.GetBytes(newLine, 0, newLine.Length, buffer, position);
+        }
+
+        return position;
+    }
+
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
     private void FlushLines()