perf: eliminate policy evaluation overhead

Benchmarks/Diagnostics/Support/NoOpAuditor.cs

@@ -7,6 +7,7 @@ namespace ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
 /// </summary>
 internal sealed class NoOpAuditor : IMutationAuditor
 {
+    public bool IsEnabled => false;
     /// <summary>
     /// Ignores the supplied audit entry.
     /// </summary>

Benchmarks/Diagnostics/Support/NoOpHistoryStore.cs

@@ -7,6 +7,7 @@ namespace ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
 /// </summary>
 internal sealed class NoOpHistoryStore : IMutationHistoryStore
 {
+    public bool IsEnabled => false;
     /// <summary>
     /// Ignores the supplied history entry.
     /// </summary>

Benchmarks/Policy/PolicyBenchmarkSupport.cs

@@ -1,11 +1,14 @@
 using Microsoft.Extensions.DependencyInjection;
 using ModularityKit.Mutator.Abstractions;
+using ModularityKit.Mutator.Abstractions.Audit;
 using ModularityKit.Mutator.Abstractions.Changes;
 using ModularityKit.Mutator.Abstractions.Context;
 using ModularityKit.Mutator.Abstractions.Engine;
+using ModularityKit.Mutator.Abstractions.History;
 using ModularityKit.Mutator.Abstractions.Intent;
 using ModularityKit.Mutator.Abstractions.Policies;
 using ModularityKit.Mutator.Abstractions.Results;
+using ModularityKit.Mutator.Benchmarks.Diagnostics.Support;
 using ModularityKit.Mutator.Runtime;
 
 namespace ModularityKit.Mutator.Benchmarks.Policy;
@@ -21,6 +24,8 @@ public static IMutationEngine BuildEngine(Action<IMutationEngine>? configure = n
     {
         var services = new ServiceCollection();
         services.AddMutators(MutationEngineOptions.Performance);
+        services.AddSingleton<IMutationAuditor>(new NoOpAuditor());
+        services.AddSingleton<IMutationHistoryStore>(new NoOpHistoryStore());
 
         var engine = services
             .BuildServiceProvider()
@@ -85,7 +90,15 @@ public MutationResult<PolicyBenchmarkState> Apply(PolicyBenchmarkState state)
     /// </summary>
     public sealed class SyncAllowBenchmarkPolicy : IMutationPolicy<PolicyBenchmarkState>
     {
-        public SyncAllowBenchmarkPolicy(int priority) => Priority = priority;
+        private readonly PolicyDecision _decision;
+        private readonly Task<PolicyDecision> _decisionTask;
+
+        public SyncAllowBenchmarkPolicy(int priority)
+        {
+            Priority = priority;
+            _decision = PolicyDecision.Allow(Name, "Synchronous benchmark policy allowed the mutation.");
+            _decisionTask = Task.FromResult(_decision);
+        }
 
         public string Name => $"{nameof(SyncAllowBenchmarkPolicy)}_{Priority}";
 
@@ -94,31 +107,43 @@ public sealed class SyncAllowBenchmarkPolicy : IMutationPolicy<PolicyBenchmarkSt
         public string? Description => "Synchronous allow policy for benchmark measurements.";
 
         public PolicyDecision Evaluate(IMutation<PolicyBenchmarkState> mutation, PolicyBenchmarkState state)
-            => PolicyDecision.Allow(Name, "Synchronous benchmark policy allowed the mutation.");
+            => _decision;
+
+        public Task<PolicyDecision> EvaluateAsync(
+            IMutation<PolicyBenchmarkState> mutation,
+            PolicyBenchmarkState state,
+            CancellationToken cancellationToken = default)
+            => _decisionTask;
     }
 
     /// <summary>
     /// Asynchronous allow policy used in benchmark scenarios.
     /// </summary>
     public sealed class AsyncAllowBenchmarkPolicy : IMutationPolicy<PolicyBenchmarkState>
     {
-        public AsyncAllowBenchmarkPolicy(int priority) => Priority = priority;
+        private readonly PolicyDecision _decision;
+        private readonly Task<PolicyDecision> _decisionTask;
+
+        public AsyncAllowBenchmarkPolicy(int priority)
+        {
+            Priority = priority;
+            _decision = PolicyDecision.Allow(Name, "Asynchronous benchmark policy allowed the mutation.");
+            _decisionTask = Task.FromResult(_decision);
+        }
 
         public string Name => $"{nameof(AsyncAllowBenchmarkPolicy)}_{Priority}";
 
         public int Priority { get; }
 
         public string? Description => "Asynchronous allow policy for benchmark measurements.";
 
-        public async Task<PolicyDecision> EvaluateAsync(
+        public Task<PolicyDecision> EvaluateAsync(
             IMutation<PolicyBenchmarkState> mutation,
             PolicyBenchmarkState state,
             CancellationToken cancellationToken = default)
         {
-            await Task.CompletedTask;
             cancellationToken.ThrowIfCancellationRequested();
-
-            return PolicyDecision.Allow(Name, "Asynchronous benchmark policy allowed the mutation.");
+            return _decisionTask;
         }
     }
 }

src/Abstractions/Policies/PolicyDecision.cs

@@ -1,7 +1,7 @@
 namespace ModularityKit.Mutator.Abstractions.Policies;
 
 /// <summary>
-/// Represents the decision of a policy regarding a mutation.
+/// Represents the decision of policy regarding mutation.
 /// Contains approval, denial, modification instructions, and metadata.
 /// </summary>
 public sealed class PolicyDecision
@@ -46,22 +46,28 @@ public sealed class PolicyDecision
     /// </summary>
     public DateTimeOffset Timestamp { get; init; } = DateTimeOffset.UtcNow;
 
+    private static readonly PolicyDecision _allow = new() { IsAllowed = true };
+
     /// <summary>
     /// Creates an allow decision.
     /// </summary>
     /// <param name="policyName">Optional policy name.</param>
     /// <param name="reason">Optional human-readable reason.</param>
     /// <returns>A policy decision that allows the mutation.</returns>
     public static PolicyDecision Allow(string? policyName = null, string? reason = null)
-        => new()
+    {
+        if (policyName is null && reason is null)
+            return _allow;
+        return new PolicyDecision
         {
             IsAllowed = true,
             PolicyName = policyName,
             Reason = reason
         };
+    }
 
     /// <summary>
-    /// Creates a deny decision with standard error severity.
+    /// Creates deny decision with standard error severity.
     /// </summary>
     /// <param name="reason">Reason for denial.</param>
     /// <param name="policyName">Optional policy name.</param>
@@ -76,7 +82,7 @@ public static PolicyDecision Deny(string reason, string? policyName = null)
         };
 
     /// <summary>
-    /// Creates a deny decision with critical severity.
+    /// Creates deny decision with critical severity.
     /// </summary>
     /// <param name="reason">Reason for denial.</param>
     /// <param name="policyName">Optional policy name.</param>
@@ -91,7 +97,7 @@ public static PolicyDecision DenyCritical(string reason, string? policyName = nu
         };
 
     /// <summary>
-    /// Creates a modification decision that adjusts mutation values.
+    /// Creates modification decision that adjusts mutation values.
     /// </summary>
     /// <param name="modifications">Dictionary of modifications to apply.</param>
     /// <param name="policyName">Optional policy name.</param>
@@ -107,7 +113,7 @@ public static PolicyDecision Modify(
         };
 
     /// <summary>
-    /// Creates a decision that requires additional approval before proceeding.
+    /// Creates decision that requires additional approval before proceeding.
     /// </summary>
     /// <param name="requirement">The requirement that must be fulfilled.</param>
     /// <param name="policyName">Optional policy name.</param>