Fix method check for callback and returns (#429)

## Summary
- refine callback/returns detection by checking method name and
containing type
- add microbenchmark comparing new vs old detection logic

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- **Tests**
- Added benchmarks to compare performance and memory usage of two
methods for identifying callback or return symbols.
- **Refactor**
- Improved detection of callback or return symbols with more precise and
reliable checks.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: rjmurillo

src/Common/SemanticModelExtensions.cs

@@ -120,14 +120,20 @@ private static bool IsCallbackOrReturnSymbol(ISymbol? symbol)
             return false;
         }
 
-        string? methodName = methodSymbol.ToString();
-
-        if (string.IsNullOrEmpty(methodName))
+        INamedTypeSymbol? containingType = methodSymbol.ContainingType;
+        if (containingType is null)
         {
             return false;
         }
 
-        return methodName.StartsWith("Moq.Language.ICallback", StringComparison.Ordinal)
-               || methodName.StartsWith("Moq.Language.IReturns", StringComparison.Ordinal);
+        string containingTypeName = containingType.ToDisplayString();
+
+        bool isCallback = string.Equals(methodSymbol.Name, "Callback", StringComparison.Ordinal)
+                          && containingTypeName.StartsWith("Moq.Language.ICallback", StringComparison.Ordinal);
+
+        bool isReturns = string.Equals(methodSymbol.Name, "Returns", StringComparison.Ordinal)
+                         && containingTypeName.StartsWith("Moq.Language.IReturns", StringComparison.Ordinal);
+
+        return isCallback || isReturns;
     }
 }

tests/Moq.Analyzers.Benchmarks/CallbackReturnsSymbolBenchmarks.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Microsoft.CodeAnalysis;
+using Moq.Analyzers.Benchmarks.Helpers;
+
+namespace Moq.Analyzers.Benchmarks;
+
+[InProcess]
+[MemoryDiagnoser]
+public class CallbackReturnsSymbolBenchmarks
+{
+    private IMethodSymbol? _callbackMethod;
+    private IMethodSymbol? _returnsMethod;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        (string Name, string Content)[] sources =
+        [
+            ("Sample", @"namespace Moq.Language { public interface ICallback { void Callback(); } public interface IReturns { void Returns(); } }")
+        ];
+
+        // Suppress VSTHRD002: Synchronously waiting on tasks or awaiters may cause deadlocks.
+        // This is required for BenchmarkDotNet compatibility and is safe in this context.
+#pragma warning disable VSTHRD002
+        Compilation? compilation = CSharpCompilationCreator.CreateAsync(sources).GetAwaiter().GetResult();
+#pragma warning restore VSTHRD002
+        if (compilation is null)
+        {
+            throw new InvalidOperationException("Failed to create C# compilation for benchmark sources.");
+        }
+
+        INamedTypeSymbol? callbackType = compilation.GetTypeByMetadataName("Moq.Language.ICallback");
+        if (callbackType is null)
+        {
+            throw new InvalidOperationException("Type 'Moq.Language.ICallback' not found in compilation.");
+        }
+
+        IMethodSymbol[] callbackMembers = callbackType.GetMembers("Callback").OfType<IMethodSymbol>().ToArray();
+        if (callbackMembers.Length != 1)
+        {
+            throw new InvalidOperationException($"Expected exactly one 'Callback' method in 'Moq.Language.ICallback', found {callbackMembers.Length}.");
+        }
+
+        _callbackMethod = callbackMembers[0];
+
+        INamedTypeSymbol? returnsType = compilation.GetTypeByMetadataName("Moq.Language.IReturns");
+        if (returnsType is null)
+        {
+            throw new InvalidOperationException("Type 'Moq.Language.IReturns' not found in compilation.");
+        }
+
+        IMethodSymbol[] returnsMembers = returnsType.GetMembers("Returns").OfType<IMethodSymbol>().ToArray();
+        if (returnsMembers.Length != 1)
+        {
+            throw new InvalidOperationException($"Expected exactly one 'Returns' method in 'Moq.Language.IReturns', found {returnsMembers.Length}.");
+        }
+
+        _returnsMethod = returnsMembers[0];
+    }
+
+    [Benchmark(Baseline = true)]
+    public bool OldCallbackCheck()
+    {
+        if (_callbackMethod is null)
+        {
+            throw new InvalidOperationException("_callbackMethod is null. Ensure Setup completed successfully.");
+        }
+
+        return OldIsCallbackOrReturnSymbol(_callbackMethod);
+    }
+
+    [Benchmark]
+    public bool NewCallbackCheck()
+    {
+        if (_callbackMethod is null)
+        {
+            throw new InvalidOperationException("_callbackMethod is null. Ensure Setup completed successfully.");
+        }
+
+        return NewIsCallbackOrReturnSymbol(_callbackMethod);
+    }
+
+    [Benchmark]
+    public bool OldReturnsCheck()
+    {
+        if (_returnsMethod is null)
+        {
+            throw new InvalidOperationException("_returnsMethod is null. Ensure Setup completed successfully.");
+        }
+
+        return OldIsCallbackOrReturnSymbol(_returnsMethod);
+    }
+
+    [Benchmark]
+    public bool NewReturnsCheck()
+    {
+        if (_returnsMethod is null)
+        {
+            throw new InvalidOperationException("_returnsMethod is null. Ensure Setup completed successfully.");
+        }
+
+        return NewIsCallbackOrReturnSymbol(_returnsMethod);
+    }
+
+    private static bool OldIsCallbackOrReturnSymbol(IMethodSymbol symbol)
+    {
+        string? methodName = symbol.ToString();
+        if (string.IsNullOrEmpty(methodName))
+        {
+            return false;
+        }
+
+        return methodName.StartsWith("Moq.Language.ICallback", StringComparison.Ordinal)
+            || methodName.StartsWith("Moq.Language.IReturns", StringComparison.Ordinal);
+    }
+
+    private static bool NewIsCallbackOrReturnSymbol(IMethodSymbol symbol)
+    {
+        INamedTypeSymbol? containingType = symbol.ContainingType;
+        if (containingType is null)
+        {
+            return false;
+        }
+
+        string containingTypeName = containingType.ToDisplayString();
+
+        bool isCallback = string.Equals(symbol.Name, "Callback", StringComparison.Ordinal)
+            && containingTypeName.StartsWith("Moq.Language.ICallback", StringComparison.Ordinal);
+
+        bool isReturns = string.Equals(symbol.Name, "Returns", StringComparison.Ordinal)
+            && containingTypeName.StartsWith("Moq.Language.IReturns", StringComparison.Ordinal);
+
+        return isCallback || isReturns;
+    }
+}