Use GetMethod.Match

Author: JohanLarsson

ReflectionAnalyzers.Tests/REFL001CastReturnValueTests/Diagnostics.MethodInfoInvoke.cs

@@ -1,4 +1,4 @@
-namespace ReflectionAnalyzers.Tests.REFL001CastReturnValueTests
+namespace ReflectionAnalyzers.Tests.REFL001CastReturnValueTests
 {
     using Gu.Roslyn.Asserts;
     using NUnit.Framework;
@@ -10,6 +10,26 @@ public static class MethodInfoInvoke
             private static readonly InvokeAnalyzer Analyzer = new();
             private static readonly ExpectedDiagnostic ExpectedDiagnostic = ExpectedDiagnostic.Create(Descriptors.REFL001CastReturnValue);
 
+            [Test]
+            public static void Simple()
+            {
+                var code = @"
+namespace N
+{
+    public class C
+    {
+        public C()
+        {
+            var value = ↓typeof(C).GetMethod(nameof(M)).Invoke(null, null);
+        }
+
+        public static int M() => 0;
+    }
+}";
+
+                RoslynAssert.Diagnostics(Analyzer, ExpectedDiagnostic, code);
+            }
+
             [Test]
             public static void Walk()
             {

ReflectionAnalyzers/Helpers/Reflection/GetMethod.cs

@@ -0,0 +1,71 @@
+namespace ReflectionAnalyzers;
+
+using System.Threading;
+
+using Gu.Roslyn.AnalyzerExtensions;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+internal readonly struct GetMethod
+{
+    internal readonly InvocationExpressionSyntax Invocation;
+    internal readonly IMethodSymbol Target;
+    internal readonly ReflectedMember Member;
+    internal readonly Name Name;
+    internal readonly Flags Flags;
+    internal readonly Types Types;
+
+    private GetMethod(InvocationExpressionSyntax invocation, IMethodSymbol target, ReflectedMember member, Name name, Flags flags, Types types)
+    {
+        this.Invocation = invocation;
+        this.Target = target;
+        this.Member = member;
+        this.Name = name;
+        this.Flags = flags;
+        this.Types = types;
+    }
+
+    internal IMethodSymbol? SingleMatch => this.Member.Match == FilterMatch.Single ? (IMethodSymbol)this.Member.Symbol! : null;
+
+    internal static GetMethod? Match(ExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken)
+    {
+        return candidate switch
+        {
+            InvocationExpressionSyntax invocation
+                => Match(invocation, semanticModel, cancellationToken),
+            PostfixUnaryExpressionSyntax { RawKind: (int)SyntaxKind.SuppressNullableWarningExpression, Operand: InvocationExpressionSyntax invocation }
+                => Match(invocation, semanticModel, cancellationToken),
+            MemberAccessExpressionSyntax { Expression: { } inner }
+                => Match(inner, semanticModel, cancellationToken),
+            IdentifierNameSyntax identifierName
+                when semanticModel.TryGetSymbol(identifierName, cancellationToken, out ILocalSymbol? local) &&
+                     AssignedValue.FindSingle(local, semanticModel, cancellationToken) is { } value
+                => Match(value, semanticModel, cancellationToken),
+            _ => null,
+        };
+    }
+
+    internal static GetMethod? Match(InvocationExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken)
+    {
+        if (candidate.TryGetTarget(KnownSymbol.Type.GetMethod, semanticModel, cancellationToken, out var target) &&
+            Flags.TryCreate(candidate, target, semanticModel, cancellationToken, out var flags) &&
+            ReflectedMember.TryGetType(candidate, semanticModel, cancellationToken, out var type, out var typeSource))
+        {
+            _ = Name.TryCreate(candidate, target, semanticModel, cancellationToken, out var name);
+            _ = Types.TryCreate(candidate, target, semanticModel, cancellationToken, out var types);
+            if (flags.AreInSufficient)
+            {
+                return new GetMethod(candidate, target, new ReflectedMember(type, typeSource, null, target, candidate, FilterMatch.InSufficientFlags), name, flags, types);
+            }
+
+            if (ReflectedMember.TryCreate(target, candidate, type, typeSource, name, flags.Effective, types, semanticModel.Compilation, out var member))
+            {
+                return new GetMethod(candidate, target, member, name, flags, types);
+            }
+        }
+
+        return null;
+    }
+}

ReflectionAnalyzers/NodeAnalzers/InvokeAnalyzer.cs

@@ -49,7 +49,7 @@ type is IArrayTypeSymbol arrayType &&
                     context.ReportDiagnostic(Diagnostic.Create(Descriptors.REFL024PreferNullOverEmptyArray, parametersArg.GetLocation()));
                 }
 
-                if (GetX.TryGetMethodInfo(memberAccess, context.SemanticModel, context.CancellationToken, out var method))
+                if (GetMethod.Match(invocation.Expression, context.SemanticModel, context.CancellationToken) is { SingleMatch: { } method })
                 {
                     if (!method.ReturnsVoid &&
                         ReturnValue.ShouldCast(invocation, method.ReturnType, context.SemanticModel))