#136 Insufficient performance

NikolayPianikov · NikolayPianikov · commit 54451be17a34 · 2026-03-09T11:32:56.000+03:00
diff --git a/src/Pure.DI.Core/Core/ApiInvocationProcessor.cs b/src/Pure.DI.Core/Core/ApiInvocationProcessor.cs
@@ -22,8 +22,6 @@ sealed class ApiInvocationProcessor(
     INameProvider nameProvider)
     : IApiInvocationProcessor
 {
-    private static readonly char[] TypeNamePartsSeparators = ['.'];
-
     public void ProcessInvocation(
         IMetadataVisitor metadataVisitor,
         SemanticModel semanticModel,
@@ -1138,17 +1136,20 @@ private void VisitFactory(
         var factoryApiWalker = factoryApiWalkerFactory();
         factoryApiWalker.Initialize(semanticModel, contextParameter, lambdaExpression);
         factoryApiWalker.Visit(lambdaExpression);
+        var contextSymbol = contextParameter.SyntaxTree == semanticModel.SyntaxTree
+            ? semanticModel.GetDeclaredSymbol(contextParameter)
+            : null;
         var resolversHasContextTag = false;
         var resolvers = factoryApiWalker.Meta
             .Where(i => i.Kind == FactoryMetaKind.Resolver)
-            .Select(meta => CreateResolver(semanticModel, resultType, meta, contextParameter, ref resolversHasContextTag, localVariableRenamingRewriter))
+            .Select(meta => CreateResolver(semanticModel, resultType, meta, contextParameter, contextSymbol, ref resolversHasContextTag, localVariableRenamingRewriter))
             .Where(i => i != default)
             .ToImmutableArray();
 
         var initializersHasContextTag = false;
         var initializers = factoryApiWalker.Meta
             .Where(i => i.Kind == FactoryMetaKind.Initializer)
-            .Select(meta => CreateInitializer(semanticModel, resultType, meta, contextParameter, ref initializersHasContextTag, localVariableRenamingRewriter))
+            .Select(meta => CreateInitializer(semanticModel, resultType, meta, contextParameter, contextSymbol, ref initializersHasContextTag, localVariableRenamingRewriter))
             .Where(i => i != default)
             .ToImmutableArray();
 
@@ -1170,12 +1171,13 @@ private MdOverride CreateOverride(
         SemanticModel semanticModel,
         OverrideMeta @override,
         ParameterSyntax contextParameter,
+        ISymbol? contextSymbol,
         ILocalVariableRenamingRewriter localVariableRenamingRewriter,
         out bool hasContextTag)
     {
         hasContextTag = false;
         var invocation = @override.Expression;
-        if (!IsContextInvocation(semanticModel, invocation, contextParameter))
+        if (!IsContextInvocation(semanticModel, invocation, contextParameter, contextSymbol))
         {
             return default;
         }
@@ -1282,11 +1284,12 @@ private MdInitializer CreateInitializer(
         ITypeSymbol resultType,
         FactoryMeta meta,
         ParameterSyntax contextParameter,
+        ISymbol? contextSymbol,
         ref bool hasContextTag,
         ILocalVariableRenamingRewriter localVariableRenamingRewriter)
     {
         var invocation = meta.Expression;
-        if (!IsContextInvocation(semanticModel, invocation, contextParameter))
+        if (!IsContextInvocation(semanticModel, invocation, contextParameter, contextSymbol))
         {
             return default;
         }
@@ -1301,7 +1304,7 @@ private MdInitializer CreateInitializer(
         // ReSharper disable once LoopCanBeConvertedToQuery
         foreach (var @override in meta.Overrides)
         {
-            var mdOverride = CreateOverride(semanticModel, @override, contextParameter, localVariableRenamingRewriter, out hasContextTag);
+            var mdOverride = CreateOverride(semanticModel, @override, contextParameter, contextSymbol, localVariableRenamingRewriter, out hasContextTag);
             if (mdOverride != default)
             {
                 overrides.Add(mdOverride);
@@ -1322,11 +1325,12 @@ private MdResolver CreateResolver(
         ITypeSymbol resultType,
         FactoryMeta meta,
         ParameterSyntax contextParameter,
+        ISymbol? contextSymbol,
         ref bool hasContextTag,
         ILocalVariableRenamingRewriter localVariableRenamingRewriter)
     {
         var invocation = meta.Expression;
-        if (!IsContextInvocation(semanticModel, invocation, contextParameter))
+        if (!IsContextInvocation(semanticModel, invocation, contextParameter, contextSymbol))
         {
             return default;
         }
@@ -1340,7 +1344,7 @@ private MdResolver CreateResolver(
         // ReSharper disable once LoopCanBeConvertedToQuery
         foreach (var overrideInvocation in meta.Overrides)
         {
-            var mdOverride = CreateOverride(semanticModel, overrideInvocation, contextParameter, localVariableRenamingRewriter, out hasContextTag);
+            var mdOverride = CreateOverride(semanticModel, overrideInvocation, contextParameter, contextSymbol, localVariableRenamingRewriter, out hasContextTag);
             if (mdOverride != default)
             {
                 overrides.Add(mdOverride);
@@ -1407,7 +1411,8 @@ private MdResolver CreateResolver(
     private static bool IsContextInvocation(
         SemanticModel semanticModel,
         InvocationExpressionSyntax invocation,
-        ParameterSyntax contextParameter)
+        ParameterSyntax contextParameter,
+        ISymbol? contextSymbol)
     {
         if (invocation.Expression is not MemberAccessExpressionSyntax
             {
@@ -1432,7 +1437,6 @@ private static bool IsContextInvocation(
             return false;
         }
 
-        var contextSymbol = semanticModel.GetDeclaredSymbol(contextParameter);
         if (contextSymbol is null)
         {
             return false;
@@ -1521,23 +1525,44 @@ private void NotSupported(SyntaxNode source) =>
 
     private IReadOnlyList<T> BuildConstantArgs<T>(
         SemanticModel semanticModel,
-        SeparatedSyntaxList<ArgumentSyntax> args) =>
-        args
-            .SelectMany(a => semantic.GetConstantValues<T>(semanticModel, a.Expression).Select(value => (value, a.Expression)))
-            .Select(a => a.value ?? throw new CompileErrorException(
-                string.Format(Strings.Error_Template_MustBeValueOfType, a.Expression, typeof(T)),
-                ImmutableArray.Create(locationProvider.GetLocation(a.Expression)),
-                LogId.ErrorMustBeValueOfType,
-                nameof(Strings.Error_Template_MustBeValueOfType)))
-            .ToList();
+        SeparatedSyntaxList<ArgumentSyntax> args)
+    {
+        var values = new List<T>(args.Count);
+        foreach (var arg in args)
+        {
+            foreach (var value in semantic.GetConstantValues<T>(semanticModel, arg.Expression))
+            {
+                if (value is null)
+                {
+                    throw new CompileErrorException(
+                        string.Format(Strings.Error_Template_MustBeValueOfType, arg.Expression, typeof(T)),
+                        ImmutableArray.Create(locationProvider.GetLocation(arg.Expression)),
+                        LogId.ErrorMustBeValueOfType,
+                        nameof(Strings.Error_Template_MustBeValueOfType));
+                }
+
+                values.Add(value);
+            }
+        }
+
+        return values;
+    }
 
     private ImmutableArray<MdTag> BuildTags(
         SemanticModel semanticModel,
-        IEnumerable<ArgumentSyntax> args) =>
-        args
-            .SelectMany(t => semantic.GetConstantValues<object>(semanticModel, t.Expression, SmartTagKind.Tag))
-            .Select((tag, i) => new MdTag(i, tag))
-            .ToImmutableArray();
+        IEnumerable<ArgumentSyntax> args)
+    {
+        var tags = new List<MdTag>();
+        foreach (var arg in args)
+        {
+            foreach (var tag in semantic.GetConstantValues<object>(semanticModel, arg.Expression, SmartTagKind.Tag))
+            {
+                tags.Add(new MdTag(tags.Count, tag));
+            }
+        }
+
+        return tags.ToImmutableArray();
+    }
 
     private static CompositionName CreateCompositionName(
         string name,
@@ -1548,9 +1573,18 @@ private static CompositionName CreateCompositionName(
         string newNamespace;
         if (!string.IsNullOrWhiteSpace(name))
         {
-            var compositionTypeNameParts = name.Split(TypeNamePartsSeparators, StringSplitOptions.RemoveEmptyEntries);
-            className = compositionTypeNameParts.Last();
-            newNamespace = string.Join(".", compositionTypeNameParts.Take(compositionTypeNameParts.Length - 1)).Trim();
+            var trimmedName = name.Trim();
+            var separatorIndex = trimmedName.LastIndexOf('.');
+            if (separatorIndex >= 0)
+            {
+                className = separatorIndex + 1 < trimmedName.Length ? trimmedName[(separatorIndex + 1)..] : "";
+                newNamespace = separatorIndex > 0 ? trimmedName[..separatorIndex] : "";
+            }
+            else
+            {
+                className = trimmedName;
+                newNamespace = "";
+            }
         }
         else
         {
diff --git a/src/Pure.DI.Core/Core/Code/Var.cs b/src/Pure.DI.Core/Core/Code/Var.cs
@@ -16,6 +16,7 @@ record Var(
 {
     private string? _codeExpression;
     private string? _baseName;
+    private string? _rootBaseName;
 
     /// <summary>
     /// Gets the type of the instance.
@@ -51,7 +52,8 @@ public string Name
             // because it can change dynamically
             if (AbstractNode.ActualLifetime == Lifetime.Singleton && constructors.IsEnabled(graph))
             {
-                return Names.RootFieldName + "." + _baseName;
+                _rootBaseName ??= Names.RootFieldName + "." + _baseName;
+                return _rootBaseName;
             }
 
             return _baseName;
diff --git a/src/Pure.DI.Core/Core/Code/VarsMap.cs b/src/Pure.DI.Core/Core/Code/VarsMap.cs
@@ -65,15 +65,24 @@ public VarInjection GetInjection(DependencyGraph graph, in Injection injection,
     public IDisposable Root(Lines lines)
     {
         return Disposables.Create(() => {
-            _map
-                .Where(i => !IsRootPersistentNode(i.Value.Declaration.Node))
-                .ToList()
-                .ForEach(i => {
+            var keysToRemove = new List<int>();
+            foreach (var item in _map)
+            {
+                if (IsRootPersistentNode(item.Value.Declaration.Node))
+                {
+                    continue;
+                }
+
 #if DEBUG
-                    lines.AppendLine($"// {i.Value.Declaration.Name}: remove ({nameof(Root)})");
+                lines.AppendLine($"// {item.Value.Declaration.Name}: remove ({nameof(Root)})");
 #endif
-                    _map.Remove(i.Key);
-                });
+                keysToRemove.Add(item.Key);
+            }
+
+            foreach (var key in keysToRemove)
+            {
+                _map.Remove(key);
+            }
 
             foreach (var var in _map.Values)
             {
@@ -93,16 +102,23 @@ public IDisposable LocalFunction(Var var, Lines lines)
         
         // Per-block variables should be isolated between local functions.
         var removed = new List<KeyValuePair<int, Var>>();
-        _map
-            .Where(i => i.Value.Declaration.Node.ActualLifetime is Lifetime.PerBlock)
-            .ToList()
-            .ForEach(i => {
+        foreach (var item in _map)
+        {
+            if (item.Value.Declaration.Node.ActualLifetime is not Lifetime.PerBlock)
+            {
+                continue;
+            }
+
 #if DEBUG
-                lines.AppendLine($"// {i.Value.Declaration.Name}: remove ({nameof(LocalFunction)})");
+            lines.AppendLine($"// {item.Value.Declaration.Name}: remove ({nameof(LocalFunction)})");
 #endif
-                removed.Add(i);
-                _map.Remove(i.Key);
-            });
+            removed.Add(item);
+        }
+
+        foreach (var item in removed)
+        {
+            _map.Remove(item.Key);
+        }
 
         return Disposables.Create(() => {
             // Cleanup and restore state after exiting the local function.
@@ -168,7 +184,7 @@ 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 IReadOnlyDictionary<int, VarState> CreateState(Var var)
+    private Dictionary<int, VarState> CreateState(Var var)
     {
         var excludeBindingId = var.Declaration.Node.BindingId;
         var result = new Dictionary<int, VarState>(_map.Count);
@@ -200,21 +216,31 @@ private void RemoveNewNonPersistentVars(Var var, IReadOnlyDictionary<int, VarSta
 #if DEBUG
         lines.AppendLine($"// remove new non-persistent vars ({reason} {var.Declaration.Name})");
 #endif
-        var newItems = _map.Where(i => {
-            if (state.ContainsKey(i.Key))
+        var newItems = new List<KeyValuePair<int, Var>>();
+        foreach (var item in _map)
+        {
+            if (state.ContainsKey(item.Key))
             {
-                return false;
+                continue;
             }
 
-            var node = i.Value.Declaration.Node;
+            var node = item.Value.Declaration.Node;
             if (node.BindingId == var.Declaration.Node.BindingId)
             {
-                return !IsNestedScopePersistentNode(node)
-                       && !ShouldKeepCurrentNodeInNestedScope(node);
+                if (!IsNestedScopePersistentNode(node)
+                    && !ShouldKeepCurrentNodeInNestedScope(node))
+                {
+                    newItems.Add(item);
+                }
+
+                continue;
             }
 
-            return !IsNestedScopePersistentNode(node);
-        }).ToList();
+            if (!IsNestedScopePersistentNode(node))
+            {
+                newItems.Add(item);
+            }
+        }
 
         foreach (var item in newItems)
         {
@@ -268,10 +294,9 @@ private void RestoreState(Var var, IReadOnlyDictionary<int, VarState> state, Lin
 
         // Find variables that were NOT in the snapshot (newly discovered in the nested scope),
         // and reset their path-specific state to defaults.
-        var stateKeys = new HashSet<int>(state.Keys);
         foreach (var item in _map)
         {
-            if (stateKeys.Contains(item.Key))
+            if (state.ContainsKey(item.Key))
             {
                 continue;
             }
@@ -295,7 +320,7 @@ private void RestoreState(Var var, IReadOnlyDictionary<int, VarState> state, Lin
         }
     }
 
-    private record VarState(
+    private readonly record struct VarState(
         Var Var,
         bool IsDeclared,
         bool IsCreated,
diff --git a/src/Pure.DI.Core/Core/Semantic.cs b/src/Pure.DI.Core/Core/Semantic.cs
@@ -2,6 +2,7 @@
 
 namespace Pure.DI.Core;
 
+using System.Collections.Concurrent;
 using Microsoft.CodeAnalysis.Operations;
 
 sealed class Semantic(
@@ -12,14 +13,22 @@ sealed class Semantic(
     CancellationToken cancellationToken)
     : ISemantic
 {
+    private readonly ConcurrentDictionary<TypeSymbolCacheKey, ITypeSymbol?> _typeSymbolCache = new();
+
     public bool IsAccessible(ISymbol symbol) =>
         symbol is { IsStatic: false, DeclaredAccessibility: Accessibility.Internal or Accessibility.Public };
 
     public T? TryGetTypeSymbol<T>(SemanticModel semanticModel, SyntaxNode node)
         where T : ITypeSymbol
     {
-        var typeInfo = semanticModel.GetTypeInfo(node, cancellationToken);
-        var typeSymbol = typeInfo.Type ?? typeInfo.ConvertedType;
+        var typeSymbol = _typeSymbolCache.GetOrAdd(
+            new TypeSymbolCacheKey(semanticModel, node),
+            key =>
+            {
+                var typeInfo = key.SemanticModel.GetTypeInfo(key.Node, cancellationToken);
+                return (typeInfo.Type ?? typeInfo.ConvertedType)?.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+            });
+
         if (typeSymbol is not T symbol)
         {
             return default;
@@ -30,7 +39,7 @@ public bool IsAccessible(ISymbol symbol) =>
             throw HandledException.Shared;
         }
 
-        return (T)symbol.WithNullableAnnotation(NullableAnnotation.NotAnnotated);
+        return symbol;
     }
 
     public T GetTypeSymbol<T>(SemanticModel semanticModel, SyntaxNode node)
@@ -378,5 +387,5 @@ private static bool TryGetValueOf<T>(object? obj, [NotNullWhen(true)] out T? val
     public bool IsValidNamespace(INamespaceSymbol? namespaceSymbol) =>
         namespaceSymbol is { IsImplicitlyDeclared: false };
 
-    internal record NodeKey(SyntaxTree Tree, string Code);
+    private readonly record struct TypeSymbolCacheKey(SemanticModel SemanticModel, SyntaxNode Node);
 }

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ record Var(`
`16`	`16`	`{`
`17`	`17`	`private string? _codeExpression;`
`18`	`18`	`private string? _baseName;`
	`19`	`+ private string? _rootBaseName;`
`19`	`20`
`20`	`21`	`/// <summary>`
`21`	`22`	`/// Gets the type of the instance.`
`@@ -51,7 +52,8 @@ public string Name`
`51`	`52`	`// because it can change dynamically`
`52`	`53`	`if (AbstractNode.ActualLifetime == Lifetime.Singleton && constructors.IsEnabled(graph))`
`53`	`54`	`{`
`54`		`- return Names.RootFieldName + "." + _baseName;`
	`55`	`+ _rootBaseName ??= Names.RootFieldName + "." + _baseName;`
	`56`	`+ return _rootBaseName;`
`55`	`57`	`}`
`56`	`58`
`57`	`59`	`return _baseName;`