Filter invocations syntactically before binding them

Twelve of the sixteen analyzers register on SyntaxKind.InvocationExpression and
call GetSymbolInfo() first, so each binds every call site in the compilation
before discovering that the method is not one of the few the rule matches. On one
170k-line project that was 30.2s of 105.3s of analyzer time; on a 30k-line project
of mostly generated EF Core migrations, 32.5s of 36.3s -- 89% of analyzer time,
and two thirds of the whole compile.

The invoked method's simple name is available syntactically and rejects nearly
every call site, so check it first. InvokedSimpleName(), MethodNames() and
CouldInvokeAnyOf() in CodeAnalysisExtensions do that; the name set is built once
per compilation from the reference symbols each analyzer already resolves, so it
tracks those automatically.

All twelve get the pre-filter, and their reference symbol lookups move out of the
per-node action. The lookups that cost the most:

- AK1006 can skip registration entirely when Akka.Persistence is absent, and its
  Persist.AddRange(PersistAsync) allocated an ImmutableArray per call site.
- AK2007's GetAllAggregateMethods() built a ten-element List and copied it into an
  ImmutableArray per call site.
- AK1007 rebuilt two arrays per call site; AK2001, AK2003, AK2004 and AK2005 each
  called GetTypeByMetadataName per call site.

AK1002 also moves its `Parent is not AwaitExpressionSyntax` test first: pure
syntax, and it discards almost everything. AK1004 was the worst offender overall
-- before binding the invocation it resolved the enclosing class symbol, for every
call site in the compilation.

Measured with csc run from a captured response file, comparing only the analyzer
assembly (process CPU, min of 4 runs):

                        Akka self-time    whole compile
  170k-line project     30.2s -> 3.7s     125.4s -> 103.0s  (99.8s without it)
  30k-line project      32.5s -> 1.5s      34.5s -> 11.6s   (11.0s without it)

That is 88% and 97% of what removing the assembly entirely would save. Those runs
predate converting AK1003, AK1004, AK1007, AK2000, AK2001 and AK2007, and the
residual 3.7s and 1.5s is largely what those six were still costing, so the table
understates this branch.

The four analyzers not registered on InvocationExpression -- AK1000, AK1005,
AK2002 and AK2006 -- are untouched.

No behavioural change intended: the pre-filter only skips nodes the subsequent
symbol comparison would have rejected. Akka.Analyzers.Tests passes 329/331 with
2 pre-existing skips.

Author: petrikero

src/Akka.Analyzers/AK1000/MustNotAwaitGracefulStopInsideReceiveAsyncAnalyzer.cs

@@ -23,9 +23,25 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Per-compilation state, hoisted out of the per-node action.
+        var gracefulStopMethods = akkaContext.AkkaCore.Actor.GracefulStopSupportSupport.GracefulStop;
+        var gracefulStopNames = gracefulStopMethods.MethodNames();
+        if (gracefulStopNames.IsEmpty)
+            return;
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var invocationExpr = (InvocationExpressionSyntax)ctx.Node;
+
+            // Check 1: GracefulStop() must not be awaited. Done first -- pure syntax, and it
+            // discards nearly every invocation.
+            if (invocationExpr.Parent is not AwaitExpressionSyntax awaitExpression)
+                return;
+
+            // Reject by name before binding.
+            if (!invocationExpr.CouldInvokeAnyOf(gracefulStopNames))
+                return;
+
             var semanticModel = ctx.SemanticModel;
             var akkaCore = akkaContext.AkkaCore;
 
@@ -36,12 +52,7 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
             methodSymbol = methodSymbol.ReducedFrom ?? methodSymbol;
 
             // Method must be one of the GracefulStop() extension methods
-            var refSymbols = akkaCore.Actor.GracefulStopSupportSupport.GracefulStop;
-            if(!refSymbols.Any(s => ReferenceEquals(methodSymbol, s)))
-                return;
-            
-            // Check 1: GracefulStop() should not be awaited
-            if (invocationExpr.Parent is not AwaitExpressionSyntax awaitExpression)
+            if(!gracefulStopMethods.Any(s => ReferenceEquals(methodSymbol, s)))
                 return;
 
             // Check 2: Ensure called within ReceiveAsync<T> or ReceiveAnyAsync lambda expression

src/Akka.Analyzers/AK1000/MustNotUseIWithTimersInPreRestartAnalyzer.cs

@@ -21,18 +21,30 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Hoisted out of the per-node action, which rebuilt both arrays per call site.
+        var iWithTimers = akkaContext.AkkaCore.Actor.ITimerScheduler;
+        var timerMethods = iWithTimers.StartPeriodicTimer.AddRange(iWithTimers.StartSingleTimer);
+        var timerMethodNames = timerMethods.MethodNames();
+        if (timerMethodNames.IsEmpty)
+            return;
+        var actorBase = akkaContext.AkkaCore.Actor.ActorBase;
+        var preRestartMethods = new[] { actorBase.PreRestart!, actorBase.AroundPreRestart! }.ToImmutableArray();
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var invocationExpr = (InvocationExpressionSyntax)ctx.Node;
+
+            // Reject by name before binding.
+            if (!invocationExpr.CouldInvokeAnyOf(timerMethodNames))
+                return;
+
             var semanticModel = ctx.SemanticModel;
 
             if (semanticModel.GetSymbolInfo(invocationExpr).Symbol is not IMethodSymbol methodInvocationSymbol)
                 return;
 
             // Invocation expression must be either `ITimerScheduler.StartPeriodicTimer()` or `ITimerScheduler.StartSingleTimer()`
-            var iWithTimers = akkaContext.AkkaCore.Actor.ITimerScheduler;
-            var refMethods = iWithTimers.StartPeriodicTimer.AddRange(iWithTimers.StartSingleTimer);
-            if (!methodInvocationSymbol.MatchesAny(refMethods))
+            if (!methodInvocationSymbol.MatchesAny(timerMethods))
                 return;
 
             // Grab the enclosing method declaration
@@ -45,9 +57,7 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
                 return;
 
             // Method declaration must be `ActorBase.PreRestart()` or `ActorBase.AroundPreRestart()`
-            var actorBase = akkaContext.AkkaCore.Actor.ActorBase;
-            refMethods = new[] { actorBase.PreRestart!, actorBase.AroundPreRestart! }.ToImmutableArray();
-            if (!methodDeclarationSymbol.OverridesAny(refMethods))
+            if (!methodDeclarationSymbol.OverridesAny(preRestartMethods))
                 return;
 
             var diagnostic = Diagnostic.Create(

src/Akka.Analyzers/AK1000/ShouldNotCallPersistInsideLoopAnalyzer.cs

@@ -20,24 +20,34 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Nothing to match without Akka.Persistence, and returning before registering spares such
+        // solutions a per-node callback for every invocation in the compilation.
+        if (!akkaContext.HasAkkaPersistenceInstalled)
+            return;
+
+        // Hoisted out of the per-node action, where the AddRange allocated a fresh ImmutableArray
+        // per call site.
+        var eventsourcedContext = akkaContext.AkkaPersistence.Eventsourced;
+        var refMethods = eventsourcedContext.Persist.AddRange(eventsourcedContext.PersistAsync);
+        var refMethodNames = refMethods.MethodNames();
+        if (refMethodNames.IsEmpty)
+            return;
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
-            // No need to check if Akka.Persistence is not installed
-            if (!akkaContext.HasAkkaPersistenceInstalled)
-                return;
-            
             var invocationExpression = (InvocationExpressionSyntax)ctx.Node;
+
+            // Reject by name before binding.
+            if (!invocationExpression.CouldInvokeAnyOf(refMethodNames))
+                return;
+
             var semanticModel = ctx.SemanticModel;
 
             // Get the member symbol from the invocation expression
             if(semanticModel.GetSymbolInfo(invocationExpression.Expression).Symbol is not IMethodSymbol methodInvocationSymbol)
                 return;
-        
-            var persistenceContext = akkaContext.AkkaPersistence;
-            
+
             // Check if the method name is `Persist` or `PersistAsync`
-            var eventsourcedContext = persistenceContext.Eventsourced;
-            var refMethods = eventsourcedContext.Persist.AddRange(eventsourcedContext.PersistAsync);
             if (!methodInvocationSymbol.MatchesAny(refMethods))
                 return;
 

src/Akka.Analyzers/AK1000/ShouldNotUseReceiveAsyncWithoutAsyncLambdaAnalyzer.cs

@@ -21,9 +21,20 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Per-compilation state, hoisted out of the per-node action.
+        var receiveActor = akkaContext.AkkaCore.Actor.ReceiveActor;
+        var receiveAsyncNames = receiveActor.ReceiveAsync.AddRange(receiveActor.ReceiveAnyAsync).MethodNames();
+        if (receiveAsyncNames.IsEmpty)
+            return;
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var invocationExpr = (InvocationExpressionSyntax)ctx.Node;
+
+            // Reject by name before binding.
+            if (!invocationExpr.CouldInvokeAnyOf(receiveAsyncNames))
+                return;
+
             var semanticModel = ctx.SemanticModel;
 
             // check that the invocation is a valid ReceiveAsync or ReceiveAnyAsync method

src/Akka.Analyzers/AK1000/ShouldNotUseSystemToCreateChildActorsAnalyzer.cs

@@ -22,9 +22,26 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Both methods this rule matches are named ActorOf.
+        var actorOfNames = new[]
+            {
+                akkaContext.AkkaCore.Actor.ActorSystem.ActorOf,
+                akkaContext.AkkaCore.Actor.ActorRefFactoryExtensions.ActorOf
+            }
+            .Where(m => m is not null)
+            .Select(m => m!.Name)
+            .ToImmutableHashSet();
+        if (actorOfNames.IsEmpty)
+            return;
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var invocationExpression = (InvocationExpressionSyntax)ctx.Node;
+
+            // Reject by name before binding.
+            if (!invocationExpression.CouldInvokeAnyOf(actorOfNames))
+                return;
+
             var semanticModel = ctx.SemanticModel;
 
             // Get the member symbol from the invocation expression

src/Akka.Analyzers/AK1000/ShouldUseIWithTimersInsteadOfScheduleTellAnalyzer.cs

@@ -21,9 +21,22 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Per-compilation state, hoisted out of the per-node action. Rejecting by name matters most
+        // here: this rule resolved the enclosing class symbol as well as the invocation, per call site.
+        var scheduleTellOnce = akkaContext.AkkaCore.Actor.ITellScheduler.ScheduleTellOnce;
+        var scheduleTellRepeatedly = akkaContext.AkkaCore.Actor.ITellScheduler.ScheduleTellRepeatedly;
+        var scheduleTellNames = scheduleTellOnce.AddRange(scheduleTellRepeatedly).MethodNames();
+        if (scheduleTellNames.IsEmpty)
+            return;
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var invocationExpr = (InvocationExpressionSyntax)ctx.Node;
+
+            // Reject by name before binding.
+            if (!invocationExpr.CouldInvokeAnyOf(scheduleTellNames))
+                return;
+
             var semanticModel = ctx.SemanticModel;
 
             var classDeclaration = invocationExpr.FirstAncestorOrSelf<ClassDeclarationSyntax>();
@@ -47,16 +60,14 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
             // Check if the method name is `ScheduleTellOnce` or `ScheduleTellRepeatedly`
             ArgumentSyntax? receiver = null;
             ArgumentSyntax? sender = null;
-            var refSymbols = akkaContext.AkkaCore.Actor.ITellScheduler.ScheduleTellOnce;
-            if (refSymbols.Any(s => ReferenceEquals(methodSymbol, s)))
+            if (scheduleTellOnce.Any(s => ReferenceEquals(methodSymbol, s)))
             {
                 receiver = invocationExpr.ArgumentList.Arguments[1];
                 sender = invocationExpr.ArgumentList.Arguments[3];
             }
             else
             {
-                refSymbols = akkaContext.AkkaCore.Actor.ITellScheduler.ScheduleTellRepeatedly;
-                if (refSymbols.Any(s => ReferenceEquals(methodSymbol, s)))
+                if (scheduleTellRepeatedly.Any(s => ReferenceEquals(methodSymbol, s)))
                 {
                     receiver = invocationExpr.ArgumentList.Arguments[2];
                     sender = invocationExpr.ArgumentList.Arguments[4];

src/Akka.Analyzers/AK2000/MustNotUseAutomaticallyHandledMessagesInsideMessageExtractorAnalyzer.cs

@@ -36,18 +36,24 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
             AnalyzeMethodDeclaration(ctx, akkaContext);
         }, SyntaxKind.MethodDeclaration);
 
+        // Per-compilation state; without the type there is nothing to match at all.
+        var hashCodeMessageExtractorSymbol =
+            context.Compilation.GetTypeByMetadataName("Akka.Cluster.Sharding.HashCodeMessageExtractor");
+        if (hashCodeMessageExtractorSymbol == null)
+            return; // couldn't find the type
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var invocationExpr = (InvocationExpressionSyntax)ctx.Node;
+
+            // The only match is HashCodeMessageExtractor.Create; reject by name before binding.
+            if (invocationExpr.InvokedSimpleName() != "Create")
+                return;
+
             var semanticModel = ctx.SemanticModel;
             if (semanticModel.GetSymbolInfo(invocationExpr).Symbol is not IMethodSymbol methodSymbol)
                 return; // couldn't find the symbol, bail out quickly
 
-            var hashCodeMessageExtractorSymbol =
-                context.Compilation.GetTypeByMetadataName("Akka.Cluster.Sharding.HashCodeMessageExtractor");
-            if (hashCodeMessageExtractorSymbol == null)
-                return; // couldn't find the type
-
             if (SymbolEqualityComparer.Default.Equals(methodSymbol.ContainingType, hashCodeMessageExtractorSymbol) &&
                 methodSymbol is { IsStatic: true, Name: "Create" })
             {

src/Akka.Analyzers/AK2000/MustNotUseTimeSpanZeroWithAskAnalyzer.cs

@@ -25,6 +25,10 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         {
             var invocationExpr = (InvocationExpressionSyntax)ctx.Node;
 
+            // The symbol check below only matches Ask; reject by name before binding.
+            if (invocationExpr.InvokedSimpleName() != "Ask")
+                return;
+
             if (ctx.SemanticModel.GetSymbolInfo(invocationExpr).Symbol is IMethodSymbol { Name: "Ask" } methodSymbol &&
                 methodSymbol.Parameters.Any(p => p.Type.ToString() == "System.TimeSpan?"))
                 foreach (var argument in invocationExpr.ArgumentList.Arguments)

src/Akka.Analyzers/AK2000/MustNotUseVoidAsyncDelegateInDslActorReceiveAnalyzer.cs

@@ -21,23 +21,30 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Per-compilation state, hoisted out of the per-node action.
+        var targetMethods = akkaContext.AkkaCore.Actor.Dsl.IActorDsl.Receive;
+        var targetMethodNames = targetMethods.MethodNames();
+        if (targetMethodNames.IsEmpty)
+            return;
+        var actionSymbol = context.Compilation.GetTypeByMetadataName("System.Action`2");
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var inv = (InvocationExpressionSyntax)ctx.Node;
+
+            // Reject by name before binding.
+            if (!inv.CouldInvokeAnyOf(targetMethodNames))
+                return;
+
             if(ctx.SemanticModel.GetSymbolInfo(inv.Expression).Symbol is not IMethodSymbol method)
                 return;
 
             if (method.IsGenericMethod)
                 method = method.OriginalDefinition;
-            
-            var compilation = context.Compilation;
-
 
-            if (!akkaContext.AkkaCore.Actor.Dsl.IActorDsl.Receive.Any(m => ReferenceEquals(method, m)))
+            if (!targetMethods.Any(m => ReferenceEquals(method, m)))
                 return;
 
-            var actionSymbol = compilation.GetTypeByMetadataName("System.Action`2");
-            
             var index = 0;
             foreach (var p in method.Parameters)
             {

src/Akka.Analyzers/AK2000/MustNotUseVoidAsyncDelegateInReceiveActorReceiveAnalyzer.cs

@@ -21,21 +21,30 @@ public override void AnalyzeCompilation(CompilationStartAnalysisContext context,
         Guard.AssertIsNotNull(context);
         Guard.AssertIsNotNull(akkaContext);
 
+        // Per-compilation state, hoisted out of the per-node action.
+        var targetMethods = akkaContext.AkkaCore.Actor.ReceiveActor.Receive;
+        var targetMethodNames = targetMethods.MethodNames();
+        if (targetMethodNames.IsEmpty)
+            return;
+        var actionSymbol = context.Compilation.GetTypeByMetadataName("System.Action`1");
+
         context.RegisterSyntaxNodeAction(ctx =>
         {
             var inv = (InvocationExpressionSyntax)ctx.Node;
+
+            // Reject by name before binding.
+            if (!inv.CouldInvokeAnyOf(targetMethodNames))
+                return;
+
             if(ctx.SemanticModel.GetSymbolInfo(inv.Expression).Symbol is not IMethodSymbol method)
                 return;
 
             if (method.IsGenericMethod)
                 method = method.OriginalDefinition;
 
-            var compilation = context.Compilation;
-            if (!akkaContext.AkkaCore.Actor.ReceiveActor.Receive.Any(m => SymbolEqualityComparer.Default.Equals(method, m)))
+            if (!targetMethods.Any(m => SymbolEqualityComparer.Default.Equals(method, m)))
                 return;
-            
-            var actionSymbol = compilation.GetTypeByMetadataName("System.Action`1");
-            
+
             var index = 0;
             foreach (var p in method.Parameters)
             {