Optimize DefaultIfNotSingle loop

src/Analyzers/SquiggleCop.Baseline.yaml

@@ -360,7 +360,7 @@
 - {Id: HAA0603, Title: Delegate allocation from a method group, Category: Performance, DefaultSeverity: Warning, IsEnabledByDefault: true, EffectiveSeverities: [Error], IsEverSuppressed: false}
 - {Id: HAA0604, Title: Delegate allocation from a method group, Category: Performance, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0004, Title: Remove Unnecessary Cast, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: true}
-- {Id: IDE0005, Title: Using directive is unnecessary., Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
+- {Id: IDE0005, Title: Using directive is unnecessary., Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: true}
 - {Id: IDE0005_gen, Title: Using directive is unnecessary., Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: true}
 - {Id: IDE0007, Title: Use implicit type, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0008, Title: Use explicit type, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}

src/Common/EnumerableExtensions.cs

@@ -1,4 +1,5 @@
-using System.Diagnostics.CodeAnalysis;
+using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Moq.Analyzers.Common;
 
@@ -16,6 +17,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 +40,26 @@ internal static class EnumerableExtensions
     /// </remarks>
     public static TSource? DefaultIfNotSingle<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
     {
+        if (source == null)
+        {
+            throw new ArgumentNullException(nameof(source));
+        }
+
+        if (predicate == null)
+        {
+            throw new ArgumentNullException(nameof(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.

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.Benchmarks/SquiggleCop.Baseline.yaml

@@ -360,7 +360,7 @@
 - {Id: HAA0603, Title: Delegate allocation from a method group, Category: Performance, DefaultSeverity: Warning, IsEnabledByDefault: true, EffectiveSeverities: [Error], IsEverSuppressed: false}
 - {Id: HAA0604, Title: Delegate allocation from a method group, Category: Performance, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0004, Title: Remove Unnecessary Cast, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: true}
-- {Id: IDE0005, Title: Using directive is unnecessary., Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
+- {Id: IDE0005, Title: Using directive is unnecessary., Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: true}
 - {Id: IDE0005_gen, Title: Using directive is unnecessary., Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: true}
 - {Id: IDE0007, Title: Use implicit type, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0008, Title: Use explicit type, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}

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

@@ -1,4 +1,6 @@
-namespace Moq.Analyzers.Test.Common;
+using System.Collections;
+
+namespace Moq.Analyzers.Test.Common;
 
 public class EnumerableExtensionsTests
 {
@@ -73,4 +75,53 @@
         int result = source.DefaultIfNotSingle(x => x > 5);
         Assert.Equal(0, result);
     }
+
+    [Fact]
+    public void DefaultIfNotSingle_StopsEnumeratingAfterSecondMatch()
+    {
+        CountingEnumerable<int> source = new(new[] { 1, 2, 3, 4 });
+        int result = source.DefaultIfNotSingle(x => x > 1);
+
+        Assert.Equal(0, result);
+        Assert.Equal(3, source.Count);
+    }
+
+    [Fact]
+    public void DefaultIfNotSingle_ThrowsArgumentNullException_WhenSourceIsNull()
+    {
+        IEnumerable<int> source = null!;
+        Assert.Throws<ArgumentNullException>(() => source.DefaultIfNotSingle(x => true));
+    }
+
+    [Fact]
+    public void DefaultIfNotSingle_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        IEnumerable<int> source = new List<int> { 1, 2, 3 };
+        Assert.Throws<ArgumentNullException>(() => source.DefaultIfNotSingle(null!));
+    }
+
+    [Fact]
+    public void DefaultIfNotSingle_ImmutableArray_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        var source = ImmutableArray.Create(1, 2, 3);
+        Assert.Throws<ArgumentNullException>(() => source.DefaultIfNotSingle(null!));
+    }
+
+    private sealed class CountingEnumerable<T>(IEnumerable<T> items) : IEnumerable<T>
+    {
+        private readonly IEnumerable<T> _items = items;
+
+        public int Count { get; private set; }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            foreach (T item in _items)
+            {
+                Count++;
+                yield return item;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
 }