Cleanup.

Author: JohanLarsson

ReflectionAnalyzers/Helpers/GetX.cs

@@ -192,116 +192,91 @@ internal static GetXResult TryGetMember(IMethodSymbol getX, ITypeSymbol targetTy
                         return GetXResult.Ambiguous;
                     }
                 }
-
-                if (member != null)
-                {
-                    return GetXResult.Single;
-                }
-
-                if (targetType.TryFindFirstMemberRecursive(name, out member))
-                {
-                    if (IsUseContainingType(member))
-                    {
-                        return GetXResult.UseContainingType;
-                    }
-
-                    if (member.MetadataName == targetMetadataName &&
-                        !MatchesFilter(member, member.MetadataName, flags, null))
-                    {
-                        return GetXResult.WrongFlags;
-                    }
-
-                    if (!member.ContainingType.Equals(targetType) &&
-                        (member.IsStatic ||
-                         flags.HasFlagFast(BindingFlags.DeclaredOnly)))
-                    {
-                        return GetXResult.WrongFlags;
-                    }
-                }
-
-                if (IsExplicitImplementation(out member))
-                {
-                    return GetXResult.ExplicitImplementation;
-                }
-
-                if (flags.HasFlagFast(BindingFlags.NonPublic) &&
-                    !targetType.Locations.Any(x => x.IsInSource))
-                {
-                    return GetXResult.Unknown;
-                }
-
-                return GetXResult.NoMatch;
             }
-
-            var current = targetType;
-            while (current != null)
+            else
             {
-                foreach (var candidate in current.GetMembers(name))
+                var current = targetType;
+                while (current != null)
                 {
-                    if (!MatchesFilter(candidate, targetMetadataName, flags, types))
-                    {
-                        continue;
-                    }
-
-                    if (IsOverriding(member, candidate))
-                    {
-                        continue;
-                    }
-
-                    if (member == null)
+                    foreach (var candidate in current.GetMembers(name))
                     {
-                        member = candidate;
-                        if (IsUseContainingType(member))
+                        if (!MatchesFilter(candidate, targetMetadataName, flags, types))
                         {
-                            return GetXResult.UseContainingType;
+                            continue;
                         }
 
-                        if (candidate.IsStatic &&
-                            !current.Equals(targetType) &&
-                            !flags.HasFlagFast(BindingFlags.FlattenHierarchy))
+                        if (IsOverriding(member, candidate))
                         {
-                            return GetXResult.WrongFlags;
+                            continue;
                         }
 
-                        if (IsWrongMemberType(candidate))
+                        if (member == null)
                         {
-                            return GetXResult.WrongMemberType;
+                            member = candidate;
+                            if (IsUseContainingType(member))
+                            {
+                                return GetXResult.UseContainingType;
+                            }
+
+                            if (candidate.IsStatic &&
+                                !current.Equals(targetType) &&
+                                !flags.HasFlagFast(BindingFlags.FlattenHierarchy))
+                            {
+                                return GetXResult.WrongFlags;
+                            }
+
+                            if (IsWrongMemberType(candidate))
+                            {
+                                return GetXResult.WrongMemberType;
+                            }
+                        }
+                        else
+                        {
+                            return GetXResult.Ambiguous;
                         }
                     }
-                    else
-                    {
-                        return GetXResult.Ambiguous;
-                    }
+
+                    current = current.BaseType;
                 }
+            }
 
-                current = current.BaseType;
+            if (member != null)
+            {
+                return GetXResult.Single;
             }
 
-            if (member == null)
+            if (targetType.TryFindFirstMemberRecursive(name, out member))
             {
-                if (targetType.TryFindFirstMemberRecursive(name, out member))
+                if (IsUseContainingType(member))
                 {
-                    if (member.MetadataName == targetMetadataName &&
-                        !MatchesFilter(member, member.MetadataName, flags, null))
-                    {
-                        return GetXResult.WrongFlags;
-                    }
+                    return GetXResult.UseContainingType;
                 }
 
-                if (IsExplicitImplementation(out member))
+                if (member.MetadataName == targetMetadataName &&
+                    !MatchesFilter(member, member.MetadataName, flags, null))
                 {
-                    return GetXResult.ExplicitImplementation;
+                    return GetXResult.WrongFlags;
                 }
 
-                if (!HasVisibleMembers(targetType, flags))
+                if (!member.ContainingType.Equals(targetType) &&
+                    (member.IsStatic ||
+                     flags.HasFlagFast(BindingFlags.DeclaredOnly)))
                 {
-                    return GetXResult.Unknown;
+                    return GetXResult.WrongFlags;
                 }
+            }
 
-                return GetXResult.NoMatch;
+            if (IsExplicitImplementation(out member))
+            {
+                return GetXResult.ExplicitImplementation;
             }
 
-            return GetXResult.Single;
+            if (!HasVisibleMembers(targetType, flags))
+            {
+                return GetXResult.Unknown;
+            }
+
+            return GetXResult.NoMatch;
 
             bool IsWrongMemberType(ISymbol symbol)
             {
@@ -626,29 +601,29 @@ private static bool MatchesFilter(ISymbol candidate, string metadataName, Bindin
 
         private static bool HasVisibleMembers(ITypeSymbol type, BindingFlags effectiveFlags)
         {
-            if (effectiveFlags.HasFlagFast(BindingFlags.NonPublic))
+            if (!effectiveFlags.HasFlagFast(BindingFlags.NonPublic))
             {
-                return !HasSuperTypeNotInSource();
+                return true;
             }
 
-            return true;
+            if (effectiveFlags.HasFlagFast(BindingFlags.DeclaredOnly))
+            {
+                return type.Locations.Any(x => x.IsInSource);
+            }
 
-            bool HasSuperTypeNotInSource()
+            var current = type;
+            while (current != null &&
+                   current != KnownSymbol.Object)
             {
-                var current = type;
-                while (current != null &&
-                       current != KnownSymbol.Object)
+                if (!current.Locations.Any(x => x.IsInSource))
                 {
-                    if (!current.Locations.Any(x => x.IsInSource))
-                    {
-                        return true;
-                    }
-
-                    current = current.BaseType;
+                    return false;
                 }
 
-                return false;
+                current = current.BaseType;
             }
+
+            return true;
         }
 
         private static bool TryGetTargetType(ExpressionSyntax expression, SyntaxNodeAnalysisContext context, PooledSet<ExpressionSyntax> visited, out ITypeSymbol result, out Optional<IdentifierNameSyntax> instance)