Significant performance improvement

src/Acuminator/Acuminator.Utilities/Roslyn/NestedInvocationWalker.cs

@@ -53,6 +53,8 @@ public abstract class NestedInvocationWalker : CSharpSyntaxWalker
 
 		private readonly ISet<(SyntaxNode, DiagnosticDescriptor)> _reportedDiagnostics = new HashSet<(SyntaxNode, DiagnosticDescriptor)>();
 
+		private readonly SymbolInfoCache _cache;
+
         /// <summary>
         /// Cancellation token
         /// </summary>
@@ -87,6 +89,8 @@ protected NestedInvocationWalker(PXContext pxContext, CancellationToken cancella
 
 			//Use lazy to avoid calling virtual methods inside the constructor
 			_typesToBypass = new Lazy<HashSet<INamedTypeSymbol>>(valueFactory: GetTypesToBypass, isThreadSafe: false);
+
+			_cache = new SymbolInfoCache(GetType());
 		}
 
 		/// <summary>
@@ -119,20 +123,22 @@ protected virtual HashSet<INamedTypeSymbol> GetTypesToBypass() =>
 		protected virtual T? GetSymbol<T>(ExpressionSyntax node)
 			where T : class, ISymbol
 		{
-			var semanticModel = GetSemanticModel(node.SyntaxTree);
-
-			if (semanticModel != null)
+			SymbolInfo? cached = _cache.GetOrCreate(node, () =>
 			{
-				var symbolInfo = semanticModel.GetSymbolInfo(node, CancellationToken);
+				SemanticModel? semanticModel = GetSemanticModel(node.SyntaxTree);
+				return semanticModel?.GetSymbolInfo(node, CancellationToken);
+			});
 
-				if (symbolInfo.Symbol is T symbol)
+			if (cached is not null)
+			{
+				if (cached.Value.Symbol is T symbol)
 				{
 					return symbol;
 				}
 
-				if (!symbolInfo.CandidateSymbols.IsEmpty)
+				if (!cached.Value.CandidateSymbols.IsEmpty)
 				{
-					return symbolInfo.CandidateSymbols.OfType<T>().FirstOrDefault();
+					return cached.Value.CandidateSymbols.OfType<T>().FirstOrDefault();
 				}
 			}
 
@@ -204,8 +210,16 @@ public override void VisitInvocationExpression(InvocationExpressionSyntax node)
 
 		public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
 		{
-			VisitPropertyOrIndexerAccessExpression(node);
-			base.VisitMemberAccessExpression(node);
+			if (node.Parent is InvocationExpressionSyntax invocation && invocation.Expression == node)
+			{
+				// we already visit this node by VisitInvocationExpression, so we just skip it here
+				base.VisitMemberAccessExpression(node);
+			}
+			else
+			{
+				VisitPropertyOrIndexerAccessExpression(node);
+				base.VisitMemberAccessExpression(node);
+			}
 		}
 
 		public override void VisitElementAccessExpression(ElementAccessExpressionSyntax node)

src/Acuminator/Acuminator.Utilities/Roslyn/SymbolInfoCache.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Acuminator.Utilities.Roslyn;
+
+/// <summary>
+/// Caches Roslyn symbol lookup results for expression syntax nodes visited by a syntax walker.
+/// </summary>
+public sealed class SymbolInfoCache
+{
+	private readonly Dictionary<ExpressionSyntax, SymbolInfo> _map = new();
+#if SYMBOL_INFO_CACHE_STATISTICS
+	private readonly SymbolInfoCacheStatistics _statistics;
+#endif
+
+	public SymbolInfoCache(Type owner)
+	{
+#if SYMBOL_INFO_CACHE_STATISTICS
+		_statistics = SymbolInfoCacheStatisticsContext.Register(owner);
+#endif
+	}
+
+	/// <summary>
+	/// Gets the cached symbol information for the specified expression, or creates and stores it using the provided factory.
+	/// </summary>
+	public SymbolInfo? GetOrCreate(ExpressionSyntax key, Func<SymbolInfo?> factory)
+	{
+		if (_map.TryGetValue(key, out SymbolInfo cached))
+		{
+#if SYMBOL_INFO_CACHE_STATISTICS
+			_statistics.Hit();
+#endif
+			return cached;
+		}
+
+#if SYMBOL_INFO_CACHE_STATISTICS
+		_statistics.Miss();
+#endif
+
+		SymbolInfo? potentialValue = factory();
+		if (potentialValue is not null)
+		{
+			_map[key] = potentialValue.Value;
+#if SYMBOL_INFO_CACHE_STATISTICS
+			_statistics.Set(key.GetType());
+#endif
+			return potentialValue;
+		}
+
+		return null;
+	}
+
+#if SYMBOL_INFO_CACHE_STATISTICS
+	public sealed class SymbolInfoCacheStatistics
+	{
+		private readonly Dictionary<Type, long> _byTypeCounter = new();
+		private readonly Type _owner;
+		private readonly int _cacheId;
+
+		private long _hitsTotal;
+		private long _missesTotal;
+		private long _setsTotal;
+
+		public SymbolInfoCacheStatistics(int cacheId, Type owner)
+		{
+			_owner = owner;
+			_cacheId = cacheId;
+		}
+
+		public void Hit() => _hitsTotal++;
+
+		public void Miss() => _missesTotal++;
+
+		public void Set(Type type)
+		{
+			if (!_byTypeCounter.ContainsKey(type))
+			{
+				_byTypeCounter[type] = 1;
+			}
+			else
+			{
+				_byTypeCounter[type]++;
+			}
+			_setsTotal++;
+		}
+
+		public StatisticsSnapshot GetSnapshot()
+		{
+			var lookupsTotal = _hitsTotal + _missesTotal;
+			return new StatisticsSnapshot(
+				_cacheId,
+				_owner,
+				_hitsTotal,
+				_missesTotal,
+				_setsTotal,
+				_byTypeCounter,
+				CalcRatio(_hitsTotal, lookupsTotal),
+				CalcRatio(_missesTotal, lookupsTotal)
+			);
+		}
+
+		private static double CalcRatio(long value, long total) => total == 0 ? 0 : (double)value / total;
+	}
+
+	public static class SymbolInfoCacheStatisticsContext
+	{
+		private static readonly object Gate = new();
+		private static readonly List<SymbolInfoCacheStatistics> Statistics = new();
+		private static int _nextCacheId;
+
+		internal static SymbolInfoCacheStatistics Register(Type owner)
+		{
+			var cacheId = Interlocked.Increment(ref _nextCacheId);
+			var statistics = new SymbolInfoCacheStatistics(cacheId, owner);
+
+			lock (Gate)
+			{
+				Statistics.Add(statistics);
+			}
+
+			return statistics;
+		}
+
+		public static StatisticsSnapshot[] GetStatistics()
+		{
+			lock (Gate)
+			{
+				var result = new StatisticsSnapshot[Statistics.Count];
+				for (var i = 0; i < Statistics.Count; i++)
+				{
+					result[i] = Statistics[i].GetSnapshot();
+				}
+
+				return result;
+			}
+		}
+	}
+
+	public record StatisticsSnapshot(int CacheId, Type Owner, long HitsTotal, long MissesTotal, long SetsTotal, Dictionary<Type, long> ByTypeCounter, double HitRatio, double MissRatio);
+#endif
+}
+