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,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.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,76 +1,160 @@
-namespace Moq.Analyzers.Test.Common;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using Xunit;
+
+namespace Moq.Analyzers.Test.Common;
 
 public class EnumerableExtensionsTests
 {
     [Fact]
     public void DefaultIfNotSingle_ReturnsNull_WhenSourceIsEmpty()
     {
-        IEnumerable<int> source = [];
-        int result = source.DefaultIfNotSingle();
-        Assert.Equal(0, result);
+        IEnumerable<object> source = [];
+        object? result = source.DefaultIfNotSingle();
+        Assert.Null(result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_ReturnsElement_WhenSourceContainsSingleElement()
     {
         int[] source = [42];
-        int result = source.DefaultIfNotSingle();
+        int? result = source.DefaultIfNotSingle();
         Assert.Equal(42, result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_ReturnsNull_WhenSourceContainsMultipleElements()
     {
         int[] source = [1, 2, 3];
-        int result = source.DefaultIfNotSingle();
+        int? result = source.DefaultIfNotSingle();
         Assert.Equal(0, result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_WithPredicate_ReturnsNull_WhenNoElementsMatch()
     {
         int[] source = [1, 2, 3];
-        int result = source.DefaultIfNotSingle(x => x > 10);
+        int? result = source.DefaultIfNotSingle(x => x > 10);
         Assert.Equal(0, result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_WithPredicate_ReturnsElement_WhenOnlyOneMatches()
     {
         int[] source = [1, 2, 3];
-        int result = source.DefaultIfNotSingle(x => x == 2);
+        int? result = source.DefaultIfNotSingle(x => x == 2);
         Assert.Equal(2, result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_WithPredicate_ReturnsNull_WhenMultipleElementsMatch()
     {
         int[] source = [1, 2, 2, 3];
-        int result = source.DefaultIfNotSingle(x => x > 1);
+        int? result = source.DefaultIfNotSingle(x => x > 1);
         Assert.Equal(0, result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_ImmutableArray_ReturnsNull_WhenEmpty()
     {
         ImmutableArray<int> source = ImmutableArray<int>.Empty;
-        int result = source.DefaultIfNotSingle(x => x > 0);
+        int? result = source.DefaultIfNotSingle(x => x > 0);
         Assert.Equal(0, result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_ImmutableArray_ReturnsElement_WhenSingleMatch()
     {
         ImmutableArray<int> source = [.. new[] { 5, 10, 15 }];
-        int result = source.DefaultIfNotSingle(x => x == 10);
+        int? result = source.DefaultIfNotSingle(x => x == 10);
         Assert.Equal(10, result);
     }
 
     [Fact]
     public void DefaultIfNotSingle_ImmutableArray_ReturnsNull_WhenMultipleMatches()
     {
         ImmutableArray<int> source = [.. new[] { 5, 10, 10, 15 }];
-        int result = source.DefaultIfNotSingle(x => x > 5);
+        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_String_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        IEnumerable<string> source = new List<string> { "a", "b", "c" };
+        ArgumentNullException ex = Assert.Throws<ArgumentNullException>(() => source.DefaultIfNotSingle(null!));
+        Assert.Equal("predicate", ex.ParamName);
+    }
+
+    [Fact]
+    public void DefaultIfNotSingle_ImmutableArray_String_ThrowsArgumentNullException_WhenPredicateIsNull()
+    {
+        ImmutableArray<string> source = ImmutableArray.Create("a", "b", "c");
+        Assert.Throws<ArgumentNullException>(() => source.DefaultIfNotSingle(null!));
+    }
+
+    [Fact]
+    public void CountingEnumerable_Count_Resets_OnEachEnumeration()
+    {
+        // The Count property resets to 0 every time GetEnumerator() is called.
+        // This means if enumeration is started but not completed, Count will reset on the next enumeration.
+        // This test verifies that behavior explicitly.
+        CountingEnumerable<int> source = new CountingEnumerable<int>(new[] { 1, 2, 3 });
+
+        // First enumeration (partial)
+        using (IEnumerator<int> enumerator = source.GetEnumerator())
+        {
+            Assert.Equal(0, source.Count); // Not started
+            Assert.True(enumerator.MoveNext()); // 1
+            Assert.Equal(1, source.Count);
+
+            // Do not complete enumeration
+        }
+
+        // Second enumeration (full)
+        List<int> items = new List<int>();
+        foreach (int item in source)
+        {
+            items.Add(item);
+        }
+
+        Assert.Equal(3, source.Count); // Count resets and counts all items
+        Assert.Equal(new[] { 1, 2, 3 }, items);
+    }
+
+    private sealed class CountingEnumerable<T>(IEnumerable<T> items) : IEnumerable<T>
+    {
+        private readonly IEnumerable<T> _items = items;
+
+        /// <summary>
+        /// Gets tracks the number of items enumerated. Resets to 0 every time <see cref="GetEnumerator"/> is called.
+        /// This means if enumeration is started but not completed, <see cref="Count"/> will reset on the next enumeration.
+        /// This behavior is intentional for test scenarios that need to track enumeration per run.
+        /// </summary>
+        public int Count { get; private set; }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            // Reset count on every new enumeration. This can cause Count to reset if enumeration is started but not completed.
+            Count = 0;
+            foreach (T item in _items)
+            {
+                Count++;
+                yield return item;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
     }
 }

tests/Moq.Analyzers.Test/SquiggleCop.Baseline.yaml

@@ -380,7 +380,7 @@
 - {Id: IDE0025, Title: Use expression body for property, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0026, Title: Use expression body for indexer, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0027, Title: Use expression body for accessor, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
-- {Id: IDE0028, Title: Simplify collection initialization, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
+- {Id: IDE0028, Title: Simplify collection initialization, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: true}
 - {Id: IDE0028, Title: Simplify collection initialization, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0029, Title: Use coalesce expression, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}
 - {Id: IDE0030, Title: Use coalesce expression, Category: Style, DefaultSeverity: Note, IsEnabledByDefault: true, EffectiveSeverities: [Note], IsEverSuppressed: false}