Optimize DefaultIfNotSingle loop

src/Common/EnumerableExtensions.cs

@@ -1,4 +1,6 @@
-using System.Diagnostics.CodeAnalysis;
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 
 namespace Moq.Analyzers.Common;
 
@@ -16,6 +18,11 @@ internal static class EnumerableExtensions
     [SuppressMessage("Performance", "ECS0900:Minimize boxing and unboxing", Justification = "Should revisit. Suppressing for now to unblock refactor.")]
     public static TSource? DefaultIfNotSingle<TSource>(this ImmutableArray<TSource> source, Func<TSource, bool> predicate)
     {
+        if (predicate == null)
+        {
+            throw new ArgumentNullException(nameof(predicate));
+        }
+
         return source.AsEnumerable().DefaultIfNotSingle(predicate);
     }
 
@@ -34,11 +41,18 @@ internal static class EnumerableExtensions
     /// </remarks>
     public static TSource? DefaultIfNotSingle<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
     {
+        ValidateDefaultIfNotSingleArguments(source, predicate);
+
         bool isFound = false;
         TSource? item = default;
 
-        foreach (TSource element in source.Where(predicate))
+        foreach (TSource element in source)
         {
+            if (!predicate(element))
+            {
+                continue;
+            }
+
             if (isFound)
             {
                 // We already found an element, thus there's multiple matches; return default.
@@ -51,4 +65,18 @@ internal static class EnumerableExtensions
 
         return item;
     }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    private static void ValidateDefaultIfNotSingleArguments<TSource>(IEnumerable<TSource> source, Func<TSource, bool> predicate)
+    {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (predicate == null)
+        {
+            throw new ArgumentNullException(nameof(predicate));
+        }
+    }
 }

tests/Moq.Analyzers.Benchmarks/DefaultIfNotSingleBaseline.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace Moq.Analyzers.Benchmarks;
+
+#pragma warning disable ECS0900 // Minimize boxing and unboxing
+internal static class DefaultIfNotSingleBaseline
+{
+    public static T? DefaultIfNotSingleBaselineMethod<T>(this IEnumerable<T> source, Func<T, bool> predicate)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        ArgumentNullException.ThrowIfNull(predicate);
+        bool found = false;
+        T? item = default;
+        foreach (T element in source.Where(predicate))
+        {
+            if (found)
+            {
+                return default;
+            }
+
+            found = true;
+            item = element;
+        }
+
+        return item;
+    }
+
+    public static T? DefaultIfNotSingleBaselineMethod<T>(this IEnumerable<T> source)
+        => source.DefaultIfNotSingleBaselineMethod(static _ => true);
+
+    public static T? DefaultIfNotSingleBaselineMethod<T>(this ImmutableArray<T> source, Func<T, bool> predicate)
+        => source.AsEnumerable().DefaultIfNotSingleBaselineMethod(predicate);
+#pragma warning restore ECS0900
+}

tests/Moq.Analyzers.Benchmarks/DefaultIfNotSingleEnumerableBenchmarks.cs

@@ -0,0 +1,17 @@
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace Moq.Analyzers.Benchmarks;
+
+[MemoryDiagnoser]
+[InProcess]
+public class DefaultIfNotSingleEnumerableBenchmarks
+{
+    private readonly IEnumerable<int> _source = Enumerable.Range(0, 100).ToArray();
+
+    [Benchmark(Baseline = true)]
+    public int? Baseline() => _source.DefaultIfNotSingleBaselineMethod(x => x == 50);
+
+    [Benchmark]
+    public int? Optimized() => _source.DefaultIfNotSingleOptimizedMethod(x => x == 50);
+}

tests/Moq.Analyzers.Benchmarks/DefaultIfNotSingleEnumerableNoPredicateBenchmarks.cs

@@ -0,0 +1,17 @@
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace Moq.Analyzers.Benchmarks;
+
+[MemoryDiagnoser]
+[InProcess]
+public class DefaultIfNotSingleEnumerableNoPredicateBenchmarks
+{
+    private readonly IEnumerable<int> _source = new[] { 0 };
+
+    [Benchmark(Baseline = true)]
+    public int? Baseline() => _source.DefaultIfNotSingleBaselineMethod();
+
+    [Benchmark]
+    public int? Optimized() => _source.DefaultIfNotSingleOptimizedMethod();
+}

tests/Moq.Analyzers.Benchmarks/DefaultIfNotSingleImmutableArrayBenchmarks.cs

@@ -0,0 +1,20 @@
+using System.Collections.Immutable;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+
+namespace Moq.Analyzers.Benchmarks;
+
+[MemoryDiagnoser]
+[InProcess]
+public class DefaultIfNotSingleImmutableArrayBenchmarks
+{
+    private readonly ImmutableArray<int> _source = ImmutableArray.CreateRange(Enumerable.Range(0, 100));
+
+#pragma warning disable ECS0900 // Minimize boxing and unboxing
+    [Benchmark(Baseline = true)]
+    public int? Baseline() => _source.DefaultIfNotSingleBaselineMethod(x => x == 50);
+
+    [Benchmark]
+    public int? Optimized() => _source.DefaultIfNotSingleOptimizedMethod(x => x == 50);
+#pragma warning restore ECS0900
+}

tests/Moq.Analyzers.Benchmarks/DefaultIfNotSingleOptimized.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+
+namespace Moq.Analyzers.Benchmarks;
+
+#pragma warning disable ECS0900 // Minimize boxing and unboxing
+internal static class DefaultIfNotSingleOptimized
+{
+    public static T? DefaultIfNotSingleOptimizedMethod<T>(this IEnumerable<T> source, Func<T, bool> predicate)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+        ArgumentNullException.ThrowIfNull(predicate);
+        bool found = false;
+        T? item = default;
+        foreach (T element in source)
+        {
+            if (!predicate(element))
+            {
+                continue;
+            }
+
+            if (found)
+            {
+                return default;
+            }
+
+            found = true;
+            item = element;
+        }
+
+        return item;
+    }
+
+    public static T? DefaultIfNotSingleOptimizedMethod<T>(this IEnumerable<T> source)
+        => source.DefaultIfNotSingleOptimizedMethod(static _ => true);
+
+    public static T? DefaultIfNotSingleOptimizedMethod<T>(this ImmutableArray<T> source, Func<T, bool> predicate)
+        => source.AsEnumerable().DefaultIfNotSingleOptimizedMethod(predicate);
+#pragma warning restore ECS0900
+}

tests/Moq.Analyzers.Test/Common/DiagnosticEditPropertiesTests.cs

@@ -0,0 +1,70 @@
+using System.Collections.Immutable;
+using Moq.Analyzers.Common;
+using Xunit;
+
+namespace Moq.Analyzers.Test.Common;
+
+public class DiagnosticEditPropertiesTests
+{
+    [Fact]
+    public void ToImmutableDictionary_RoundTripsProperties()
+    {
+        DiagnosticEditProperties props = new DiagnosticEditProperties { TypeOfEdit = DiagnosticEditProperties.EditType.Insert, EditPosition = 2 };
+        ImmutableDictionary<string, string?> dict = props.ToImmutableDictionary();
+        Assert.Equal("Insert", dict[DiagnosticEditProperties.EditTypeKey]);
+        Assert.Equal("2", dict[DiagnosticEditProperties.EditPositionKey]);
+    }
+
+    [Fact]
+    public void TryGetFromImmutableDictionary_Succeeds_WithValidDictionary()
+    {
+        ImmutableDictionary<string, string?> dict = ImmutableDictionary<string, string?>.Empty
+            .Add(DiagnosticEditProperties.EditTypeKey, "Replace")
+            .Add(DiagnosticEditProperties.EditPositionKey, "5");
+        bool result = DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out DiagnosticEditProperties? props);
+        Assert.True(result);
+        Assert.NotNull(props);
+        Assert.Equal(DiagnosticEditProperties.EditType.Replace, props!.TypeOfEdit);
+        Assert.Equal(5, props.EditPosition);
+    }
+
+    [Fact]
+    public void TryGetFromImmutableDictionary_Fails_WhenEditTypeKeyMissing()
+    {
+        ImmutableDictionary<string, string?> dict = ImmutableDictionary<string, string?>.Empty.Add(DiagnosticEditProperties.EditPositionKey, "1");
+        bool result = DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out DiagnosticEditProperties? props);
+        Assert.False(result);
+        Assert.Null(props);
+    }
+
+    [Fact]
+    public void TryGetFromImmutableDictionary_Fails_WhenEditPositionKeyMissing()
+    {
+        ImmutableDictionary<string, string?> dict = ImmutableDictionary<string, string?>.Empty.Add(DiagnosticEditProperties.EditTypeKey, "Insert");
+        bool result = DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out DiagnosticEditProperties? props);
+        Assert.False(result);
+        Assert.Null(props);
+    }
+
+    [Fact]
+    public void TryGetFromImmutableDictionary_Fails_WhenEditTypeInvalid()
+    {
+        ImmutableDictionary<string, string?> dict = ImmutableDictionary<string, string?>.Empty
+            .Add(DiagnosticEditProperties.EditTypeKey, "NotAType")
+            .Add(DiagnosticEditProperties.EditPositionKey, "1");
+        bool result = DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out DiagnosticEditProperties? props);
+        Assert.False(result);
+        Assert.Null(props);
+    }
+
+    [Fact]
+    public void TryGetFromImmutableDictionary_Fails_WhenEditPositionInvalid()
+    {
+        ImmutableDictionary<string, string?> dict = ImmutableDictionary<string, string?>.Empty
+            .Add(DiagnosticEditProperties.EditTypeKey, "Insert")
+            .Add(DiagnosticEditProperties.EditPositionKey, "notAnInt");
+        bool result = DiagnosticEditProperties.TryGetFromImmutableDictionary(dict, out DiagnosticEditProperties? props);
+        Assert.False(result);
+        Assert.Null(props);
+    }
+}