Simplify SA1410 overload analysis using the speculative semantic model

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/MaintainabilityRules/SA1410UnitTests.cs

@@ -121,6 +121,7 @@ public void TestMethod()
         });
 
         this.TestMethod2(delegate() { return true; });
+        this.TestMethod3(delegate() { return true; });
     }
 
     public void TestMethod2(Delegate1 d)
@@ -131,6 +132,17 @@ public void TestMethod2(Delegate2 d)
     {
     }
 }
+
+public static class TestClassExtensions
+{
+    public static void TestMethod3(this TestClass obj, TestClass.Delegate1 d)
+    {
+    }
+
+    public static void TestMethod3(this TestClass obj, TestClass.Delegate2 d)
+    {
+    }
+}
 ";
 
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
@@ -155,6 +167,7 @@ public void TestMethod()
         this.TestMethod3(0, delegate() { return true; });
         this.TestMethod4(delegate() { return true; }, 1);
         this.TestMethod5(delegate() { return true; });
+        this.TestMethod6(delegate() { return true; });
     }
 
     public void TestMethod2(Delegate1 d)
@@ -188,6 +201,17 @@ public void TestMethod5(Delegate1 d)
     public void TestMethod5(Delegate2 d, double x)
     {
     }
+
+    public void TestMethod6(Delegate1 d)
+    {
+    }
+}
+
+public static class TestClassExtensions
+{
+    public static void TestMethod6(this TestClass obj, TestClass.Delegate2 d)
+    {
+    }
 }
 ";
 
@@ -197,6 +221,7 @@ public void TestMethod5(Delegate2 d, double x)
                 this.CSharpDiagnostic().WithLocation(9, 37),
                 this.CSharpDiagnostic().WithLocation(10, 34),
                 this.CSharpDiagnostic().WithLocation(11, 34),
+                this.CSharpDiagnostic().WithLocation(12, 34),
             };
 
             await this.VerifyCSharpDiagnosticAsync(testCode, expectedResults, CancellationToken.None).ConfigureAwait(false);

StyleCop.Analyzers/StyleCop.Analyzers/MaintainabilityRules/SA1410RemoveDelegateParenthesisWhenPossible.cs

@@ -5,8 +5,6 @@ namespace StyleCop.Analyzers.MaintainabilityRules
 {
     using System;
     using System.Collections.Immutable;
-    using System.Linq;
-    using System.Threading;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -93,7 +91,7 @@ private static void HandleAnonymousMethodExpression(SyntaxNodeAnalysisContext co
                 {
                 case SyntaxKind.ObjectCreationExpression:
                 case SyntaxKind.InvocationExpression:
-                    if (HasAmbiguousOverload(context, argumentListSyntax.Arguments.IndexOf(argumentSyntax), argumentListSyntax.Parent))
+                    if (HasAmbiguousOverload(context, syntax, argumentListSyntax.Parent))
                     {
                         return;
                     }
@@ -106,36 +104,11 @@ private static void HandleAnonymousMethodExpression(SyntaxNodeAnalysisContext co
             context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.ParameterList.GetLocation()));
         }
 
-        private static bool HasAmbiguousOverload(SyntaxNodeAnalysisContext context, int parameterIndex, SyntaxNode methodCallSyntax)
+        private static bool HasAmbiguousOverload(SyntaxNodeAnalysisContext context, AnonymousMethodExpressionSyntax anonymousMethodExpression, SyntaxNode methodCallSyntax)
         {
-            var methodSymbol = (IMethodSymbol)context.SemanticModel.GetSymbolInfo(methodCallSyntax, context.CancellationToken).Symbol;
-
-            var nameOverloads = methodSymbol.ContainingType.GetMembers(methodSymbol.Name);
-            var parameterCountMatchingOverloads = nameOverloads.OfType<IMethodSymbol>().Where(symbol => (symbol != methodSymbol) && (symbol.Parameters.Length == methodSymbol.Parameters.Length));
-
-            foreach (var overload in parameterCountMatchingOverloads)
-            {
-                var isAmbiguousOverload = true;
-
-                for (var i = 0; isAmbiguousOverload && (i < methodSymbol.Parameters.Length); i++)
-                {
-                    if (i == parameterIndex)
-                    {
-                        isAmbiguousOverload = overload.Parameters[i].Type.TypeKind == TypeKind.Delegate;
-                    }
-                    else
-                    {
-                        isAmbiguousOverload = methodSymbol.Parameters[i].Type == overload.Parameters[i].Type;
-                    }
-                }
-
-                if (isAmbiguousOverload)
-                {
-                    return true;
-                }
-            }
-
-            return false;
+            var nodeForSpeculation = methodCallSyntax.ReplaceNode(anonymousMethodExpression, anonymousMethodExpression.WithParameterList(null));
+            var speculativeSymbolInfo = context.SemanticModel.GetSpeculativeSymbolInfo(methodCallSyntax.SpanStart, nodeForSpeculation, SpeculativeBindingOption.BindAsExpression);
+            return speculativeSymbolInfo.Symbol == null;
         }
     }
 }