GetConstructor

Author: JohanLarsson

ReflectionAnalyzers.Tests/Helpers/Reflection/GetXTests.GetMethodOverloadResolution.cs

@@ -0,0 +1,78 @@
+namespace ReflectionAnalyzers;
+
+using System.Threading;
+
+using Gu.Roslyn.AnalyzerExtensions;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+internal readonly struct GetConstructor
+{
+    internal readonly InvocationExpressionSyntax Invocation;
+    internal readonly IMethodSymbol Target;
+    internal readonly ReflectedMember Member;
+    internal readonly Flags Flags;
+    internal readonly Types Types;
+
+    private GetConstructor(InvocationExpressionSyntax invocation, IMethodSymbol target, ReflectedMember member, Flags flags, Types types)
+    {
+        this.Invocation = invocation;
+        this.Target = target;
+        this.Member = member;
+        this.Flags = flags;
+        this.Types = types;
+    }
+
+    internal IMethodSymbol? Single => this.Member.Match == FilterMatch.Single ? (IMethodSymbol)this.Member.Symbol! : null;
+
+    /// <summary>
+    /// Check if <paramref name="candidate"/> is a call to Type.GetConstructor.
+    /// </summary>
+    internal static GetConstructor? 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,
+        };
+    }
+
+    /// <summary>
+    /// Check if <paramref name="candidate"/> is a call to Type.GetConstructor.
+    /// </summary>
+    internal static GetConstructor? Match(InvocationExpressionSyntax candidate, SemanticModel semanticModel, CancellationToken cancellationToken)
+    {
+        if (candidate.TryGetTarget(KnownSymbol.Type.GetConstructor, semanticModel, cancellationToken, out var target))
+        {
+            if (ReflectedMember.TryGetType(candidate, semanticModel, cancellationToken, out var type, out var typeSource) &&
+                Flags.TryCreate(candidate, target, semanticModel, cancellationToken, out var flags) &&
+                Types.TryCreate(candidate, target, semanticModel, cancellationToken, out var types))
+            {
+                return ReflectedMember.TryCreate(target, candidate, type, typeSource, Name.Ctor, flags.Effective, types, semanticModel.Compilation, out var member)
+                    ? new GetConstructor(candidate, target, member, flags, types)
+                    : null;
+            }
+
+            if (Flags.TryCreate(candidate, target, semanticModel, cancellationToken, out flags) &&
+                flags.AreInSufficient)
+            {
+                var member = new ReflectedMember(type, typeSource, null, target, candidate, FilterMatch.InSufficientFlags);
+                _ = Types.TryCreate(candidate, target, semanticModel, cancellationToken, out types);
+                return new GetConstructor(candidate, target, member, flags, types);
+            }
+        }
+
+        return null;
+    }
+}

ReflectionAnalyzers/Helpers/Reflection/GetConstructor.cs

@@ -675,7 +675,7 @@ private static bool ShouldUseSameTypeAsParameter(ReflectedMember member, Types t
 
                 for (var i = 0; i < method.Parameters.Length; i++)
                 {
-                    if (!TypeSymbolComparer.Equal(types.Symbols[i], Effective(method.Parameters[i].Type)) &&
+                    if (!TypeSymbolComparer.Equal(types.Symbols[i], EffectiveType(method.Parameters[i].Type)) &&
                         context.SemanticModel.IsAccessible(context.Node.SpanStart, method.Parameters[i].Type))
                     {
                         typeText = method.Parameters[i].Type.ToString(context);
@@ -688,7 +688,7 @@ private static bool ShouldUseSameTypeAsParameter(ReflectedMember member, Types t
                         return true;
                     }
 
-                    ITypeSymbol Effective(ITypeSymbol t) =>
+                    static ITypeSymbol EffectiveType(ITypeSymbol t) =>
                         t.NullableAnnotation == NullableAnnotation.Annotated
                             ? t.WithNullableAnnotation(NullableAnnotation.None)
                             : t;

ReflectionAnalyzers/NodeAnalzers/GetXAnalyzer.cs

@@ -33,7 +33,7 @@ public override void Initialize(AnalysisContext context)
         private static void Handle(SyntaxNodeAnalysisContext context)
         {
             if (!context.IsExcludedFromAnalysis() &&
-                context.Node is InvocationExpressionSyntax { ArgumentList: { }, Expression: MemberAccessExpressionSyntax memberAccess } invocation &&
+                context.Node is InvocationExpressionSyntax { ArgumentList: { } } invocation &&
                 invocation.TryGetMethodName(out var name) &&
                 name == "Invoke" &&
                 context.SemanticModel.TryGetSymbol(invocation, context.CancellationToken, out var invoke) &&
@@ -140,7 +140,7 @@ type is IArrayTypeSymbol arrayType &&
                         }
                     }
                 }
-                else if (GetX.TryGetConstructorInfo(memberAccess, context.SemanticModel, context.CancellationToken, out var ctor))
+                else if (GetConstructor.Match(invocation.Expression, context.SemanticModel, context.CancellationToken) is { Single: { } ctor })
                 {
                     if (ReturnValue.ShouldCast(invocation, ctor.ReturnType, context.SemanticModel))
                     {