Refactor: GetX.IsKnownSignature, allow Binder & ParameterModifier[] as long as they are null.

Author: JohanLarsson

ReflectionAnalyzers/Helpers/GetX.cs

@@ -3,6 +3,7 @@ namespace ReflectionAnalyzers
     using System.Linq;
     using Gu.Roslyn.AnalyzerExtensions;
     using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
 
@@ -41,7 +42,7 @@ internal static class GetX
             if (invocation.ArgumentList != null &&
                 invocation.TryGetTarget(KnownSymbol.Type.GetMethod, context.SemanticModel, context.CancellationToken, out var getX) &&
                 TryGetTargetType(invocation, context, out targetType, out _) &&
-                IsKnownSignature(getX) &&
+                IsKnownSignature(getX, invocation) &&
                 TryGetName(invocation, getX, context, out nameArg, out targetName) &&
                 (TryGetFlags(invocation, getX, context, out flagsArg, out flags) ||
                  TryGetDefaultFlags(KnownSymbol.Type.GetMethod, out flags)))
@@ -50,16 +51,6 @@ internal static class GetX
             }
 
             return null;
-
-            bool IsKnownSignature(IMethodSymbol candidate)
-            {
-                // I don't know how binder works so limiting checks to what I know.
-                return (candidate.Parameters.TrySingle(out var nameParameter) &&
-                        nameParameter.Type == KnownSymbol.String) ||
-                       (candidate.Parameters.Length == 2 &&
-                        candidate.Parameters.TrySingle(x => x.Type == KnownSymbol.String, out nameParameter) &&
-                        candidate.Parameters.TrySingle(x => x.Type == KnownSymbol.BindingFlags, out _));
-            }
         }
 
         /// <summary>
@@ -76,7 +67,7 @@ bool IsKnownSignature(IMethodSymbol candidate)
             if (invocation.ArgumentList != null &&
                 invocation.TryGetTarget(KnownSymbol.Type.GetMember, context.SemanticModel, context.CancellationToken, out var getX) &&
                 TryGetTargetType(invocation, context, out targetType, out _) &&
-                IsKnownSignature(getX) &&
+                IsKnownSignature(getX, invocation) &&
                 TryGetName(invocation, getX, context, out nameArg, out targetName) &&
                 (TryGetFlags(invocation, getX, context, out flagsArg, out flags) ||
                  TryGetDefaultFlags(KnownSymbol.Type.GetMember, out flags)))
@@ -85,16 +76,6 @@ bool IsKnownSignature(IMethodSymbol candidate)
             }
 
             return null;
-
-            bool IsKnownSignature(IMethodSymbol candidate)
-            {
-                // I don't know how binder works so limiting checks to what I know.
-                return (candidate.Parameters.TrySingle(out var nameParameter) &&
-                        nameParameter.Type == KnownSymbol.String) ||
-                       (candidate.Parameters.Length == 2 &&
-                        candidate.Parameters.TrySingle(x => x.Type == KnownSymbol.String, out nameParameter) &&
-                        candidate.Parameters.TrySingle(x => x.Type == KnownSymbol.BindingFlags, out _));
-            }
         }
 
         /// <summary>
@@ -328,7 +309,7 @@ bool IsOverriding(ISymbol symbol, ISymbol candidateBase)
                 return false;
             }
 
-            bool IsExplicitImplementation( out ISymbol result)
+            bool IsExplicitImplementation(out ISymbol result)
             {
                 foreach (var @interface in targetType.AllInterfaces)
                 {
@@ -378,6 +359,33 @@ internal static bool TryGetDefaultFlags(QualifiedMethod getX, out BindingFlags d
             return false;
         }
 
+        /// <summary>
+        /// Defensive check to only handle known cases. Don't know how the binder works.
+        /// </summary>
+        private static bool IsKnownSignature(IMethodSymbol candidate, InvocationExpressionSyntax invocation)
+        {
+            foreach (var parameter in candidate.Parameters)
+            {
+                if (!IsKnownArgument(parameter))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+            bool IsKnownArgument(IParameterSymbol parameter)
+            {
+                if (parameter.Type == KnownSymbol.String ||
+                    parameter.Type == KnownSymbol.BindingFlags)
+                {
+                    return true;
+                }
+
+                return invocation.TryFindArgument(parameter, out var argument) &&
+                       argument.Expression?.IsKind(SyntaxKind.NullLiteralExpression) == true;
+            }
+        }
+
         /// <summary>
         /// Handles GetField, GetEvent, GetMember, GetMethod...
         /// </summary>

ReflectionAnalyzers/Helpers/KnownSymbols/KnownSymbol.cs

@@ -12,6 +12,9 @@ internal static class KnownSymbol
         internal static readonly AttributeType Attribute = new AttributeType();
         internal static readonly AssemblyType Assembly = new AssemblyType();
         internal static readonly QualifiedType BindingFlags = Create("System.Reflection.BindingFlags");
+        internal static readonly QualifiedType Binder = Create("System.Reflection.Binder");
+        internal static readonly QualifiedType ParameterModifier = Create("System.Reflection.ParameterModifier");
+        internal static readonly QualifiedType CallingConventions = Create("System.Reflection.CallingConventions");
         internal static readonly ConstructorInfoType ConstructorInfo = new ConstructorInfoType();
         internal static readonly EventInfoType EventInfo = new EventInfoType();
         internal static readonly FieldInfoType FieldInfo = new FieldInfoType();