Fix tests.

JohanLarsson · JohanLarsson · commit 5f61ad499a50 · 2018-09-24T20:20:21.000+02:00
diff --git a/ReflectionAnalyzers.Tests/REFL003MemberDoesNotExistTests/Diagnostics.cs b/ReflectionAnalyzers.Tests/REFL003MemberDoesNotExistTests/Diagnostics.cs
@@ -133,7 +133,7 @@ class Foo
     {
         public Foo()
         {
-            var member = typeof(CustomAggregateException).GetField(""MISSING"", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Instance | BindingFlags.DeclaredOnly);
+            var member = typeof(CustomAggregateException).GetField(↓""MISSING"", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly);
         }
     }
 }";
diff --git a/ReflectionAnalyzers.Tests/REFL003MemberDoesNotExistTests/ValidCode.GetMethod.cs b/ReflectionAnalyzers.Tests/REFL003MemberDoesNotExistTests/ValidCode.GetMethod.cs
@@ -8,8 +8,7 @@ internal partial class ValidCode
         internal class GetMethod
         {
             [TestCase("typeof(Foo).GetMethod(nameof(PublicStatic))")]
-            [TestCase("typeof(Foo).GetMethod(nameof(ReferenceEquals))")]
-            [TestCase("typeof(Foo).GetMethod(nameof(ReferenceEquals), BindingFlags.Public | BindingFlags.Static)")]
+            [TestCase("typeof(Foo).GetMethod(nameof(ReferenceEquals), BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy)")]
             [TestCase("typeof(Foo).GetMethod(nameof(this.PublicInstance))")]
             [TestCase("typeof(Foo).GetMethod(nameof(PublicInstance))")]
             [TestCase("typeof(Foo).GetMethod(nameof(this.ToString))")]
diff --git a/ReflectionAnalyzers.Tests/REFL003MemberDoesNotExistTests/ValidCode.cs b/ReflectionAnalyzers.Tests/REFL003MemberDoesNotExistTests/ValidCode.cs
@@ -32,7 +32,6 @@ public Foo()
         }
 
         [TestCase("GetMethod(\"get_InnerExceptionCount\", BindingFlags.NonPublic | BindingFlags.Instance)")]
-        [TestCase("GetMethod(\"get_InnerExceptionCount\", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)")]
         public void SubclassAggregateExceptionGetInnerExceptionCount(string call)
         {
             var exception = @"
diff --git a/ReflectionAnalyzers.Tests/REFL005WrongBindingFlagsTests/CodeFix.cs b/ReflectionAnalyzers.Tests/REFL005WrongBindingFlagsTests/CodeFix.cs
@@ -145,6 +145,7 @@ public Foo()
         private int Private() => 0;
     }
 }".AssertReplace("nameof(this.Public)", $"nameof({method})");
+
             var fixedCode = @"
 namespace RoslynSandbox
 {
@@ -167,6 +168,7 @@ public Foo()
     }
 }".AssertReplace("nameof(this.Public)", $"nameof({method})")
   .AssertReplace("BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly", expected);
+
             var message = $"There is no member matching the filter. Expected: {expected}.";
             AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic.WithMessage(message), code, fixedCode);
         }
diff --git a/ReflectionAnalyzers.Tests/REFL005WrongBindingFlagsTests/Diagnostics.cs b/ReflectionAnalyzers.Tests/REFL005WrongBindingFlagsTests/Diagnostics.cs
@@ -9,6 +9,7 @@ internal class Diagnostics
         private static readonly DiagnosticAnalyzer Analyzer = new GetXAnalyzer();
         private static readonly ExpectedDiagnostic ExpectedDiagnostic = ExpectedDiagnostic.Create(REFL005WrongBindingFlags.Descriptor);
 
+        [Explicit("Temp")]
         [TestCase("GetConstructor(↓Type.EmptyTypes)")]
         [TestCase("GetConstructor(↓Array.Empty<Type>())")]
         [TestCase("GetConstructor(↓new Type[0])")]
diff --git a/ReflectionAnalyzers/Helpers/GetX.cs b/ReflectionAnalyzers/Helpers/GetX.cs
@@ -143,38 +143,38 @@ internal static bool TryGetTargetType(InvocationExpressionSyntax getX, SyntaxNod
                    TryGetTargetType(memberAccess.Expression, context, null, out result, out instance);
         }
 
-        internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetType, string targetMetadataName, BindingFlags effectiveFlags, IReadOnlyList<ITypeSymbol> types, SyntaxNodeAnalysisContext context, out ISymbol target)
+        internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetType, string targetMetadataName, BindingFlags flags, IReadOnlyList<ITypeSymbol> types, SyntaxNodeAnalysisContext context, out ISymbol target)
         {
             var name = TrimName();
             target = null;
             if (targetType is ITypeParameterSymbol typeParameter)
             {
                 if (typeParameter.ConstraintTypes.Length == 0)
                 {
-                    return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, effectiveFlags, types, context, out target);
+                    return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, flags, types, context, out target);
                 }
 
                 foreach (var constraintType in typeParameter.ConstraintTypes)
                 {
-                    var result = TryGetTarget(getX, constraintType, name, effectiveFlags, types, context, out target);
+                    var result = TryGetTarget(getX, constraintType, name, flags, types, context, out target);
                     if (result != GetXResult.NoMatch)
                     {
                         return result;
                     }
                 }
 
-                return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, effectiveFlags, types, context, out target);
+                return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, flags, types, context, out target);
             }
 
             if (getX == KnownSymbol.Type.GetNestedType ||
-                effectiveFlags.HasFlagFast(BindingFlags.DeclaredOnly) ||
-                (effectiveFlags.HasFlagFast(BindingFlags.Static) &&
-                 !effectiveFlags.HasFlagFast(BindingFlags.Instance) &&
-                 !effectiveFlags.HasFlagFast(BindingFlags.FlattenHierarchy)))
+                flags.HasFlagFast(BindingFlags.DeclaredOnly) ||
+                (flags.HasFlagFast(BindingFlags.Static) &&
+                 !flags.HasFlagFast(BindingFlags.Instance) &&
+                 !flags.HasFlagFast(BindingFlags.FlattenHierarchy)))
             {
                 foreach (var member in targetType.GetMembers(name))
                 {
-                    if (!MatchesFilter(member, targetMetadataName, effectiveFlags, types))
+                    if (!MatchesFilter(member, targetMetadataName, flags, types))
                     {
                         continue;
                     }
@@ -209,15 +209,27 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy
                         return GetXResult.UseContainingType;
                     }
 
-                    return GetXResult.WrongFlags;
+                    if (target.MetadataName == targetMetadataName &&
+                        !MatchesFilter(target, target.MetadataName, flags, null))
+                    {
+                        return GetXResult.WrongFlags;
+                    }
+
+                    if (!target.ContainingType.Equals(targetType) &&
+                        (target.IsStatic ||
+                         flags.HasFlagFast(BindingFlags.DeclaredOnly)))
+                    {
+                        return GetXResult.WrongFlags;
+                    }
                 }
 
                 if (IsExplicitImplementation(out target))
                 {
                     return GetXResult.ExplicitImplementation;
                 }
 
-                if (!HasVisibleMembers(targetType, effectiveFlags))
+                if (flags.HasFlagFast(BindingFlags.NonPublic) &&
+                    !targetType.Locations.Any(x => x.IsInSource))
                 {
                     return GetXResult.Unknown;
                 }
@@ -230,14 +242,7 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy
             {
                 foreach (var member in current.GetMembers(name))
                 {
-                    if (!MatchesFilter(member, targetMetadataName, effectiveFlags, types))
-                    {
-                        continue;
-                    }
-
-                    if (member.IsStatic &&
-                        !current.Equals(targetType) &&
-                        !effectiveFlags.HasFlagFast(BindingFlags.FlattenHierarchy))
+                    if (!MatchesFilter(member, targetMetadataName, flags, types))
                     {
                         continue;
                     }
@@ -252,6 +257,13 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy
                             return GetXResult.UseContainingType;
                         }
 
+                        if (member.IsStatic &&
+                            !current.Equals(targetType) &&
+                            !flags.HasFlagFast(BindingFlags.FlattenHierarchy))
+                        {
+                            return GetXResult.WrongFlags;
+                        }
+
                         if (IsOfWrongType(member))
                         {
                             return GetXResult.WrongMemberType;
@@ -274,15 +286,19 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy
             {
                 if (targetType.TryFindFirstMemberRecursive(name, out target))
                 {
-                    return GetXResult.WrongFlags;
+                    if (target.MetadataName == targetMetadataName &&
+                        !MatchesFilter(target, target.MetadataName, flags, null))
+                    {
+                        return GetXResult.WrongFlags;
+                    }
                 }
 
                 if (IsExplicitImplementation(out target))
                 {
                     return GetXResult.ExplicitImplementation;
                 }
 
-                if (!HasVisibleMembers(targetType, effectiveFlags))
+                if (!HasVisibleMembers(targetType, flags))
                 {
                     return GetXResult.Unknown;
                 }

Original file line number	Diff line number	Diff line change
`@@ -133,7 +133,7 @@ class Foo`
`133`	`133`	`{`
`134`	`134`	`public Foo()`
`135`	`135`	`{`
`136`		`- var member = typeof(CustomAggregateException).GetField(""MISSING"", BindingFlags.NonPublic \| BindingFlags.Instance \| BindingFlags.Instance \| BindingFlags.DeclaredOnly);`
	`136`	`+ var member = typeof(CustomAggregateException).GetField(↓""MISSING"", BindingFlags.NonPublic \| BindingFlags.Instance \| BindingFlags.DeclaredOnly);`
`137`	`137`	`}`
`138`	`138`	`}`
`139`	`139`	`}";`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,6 @@ public Foo()`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`[TestCase("GetMethod(\"get_InnerExceptionCount\", BindingFlags.NonPublic \| BindingFlags.Instance)")]`
`35`		`- [TestCase("GetMethod(\"get_InnerExceptionCount\", BindingFlags.NonPublic \| BindingFlags.Instance \| BindingFlags.DeclaredOnly)")]`
`36`	`35`	`public void SubclassAggregateExceptionGetInnerExceptionCount(string call)`
`37`	`36`	`{`
`38`	`37`	`var exception = @"`
Original file line number	Diff line number	Diff line change
`@@ -145,6 +145,7 @@ public Foo()`
`145`	`145`	`private int Private() => 0;`
`146`	`146`	`}`
`147`	`147`	`}".AssertReplace("nameof(this.Public)", $"nameof({method})");`
	`148`	`+`
`148`	`149`	`var fixedCode = @"`
`149`	`150`	`namespace RoslynSandbox`
`150`	`151`	`{`
`@@ -167,6 +168,7 @@ public Foo()`
`167`	`168`	`}`
`168`	`169`	`}".AssertReplace("nameof(this.Public)", $"nameof({method})")`
`169`	`170`	`.AssertReplace("BindingFlags.Public \| BindingFlags.Instance \| BindingFlags.DeclaredOnly", expected);`
	`171`	`+`
`170`	`172`	`var message = $"There is no member matching the filter. Expected: {expected}.";`
`171`	`173`	`AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic.WithMessage(message), code, fixedCode);`
`172`	`174`	`}`
Original file line number	Diff line number	Diff line change
`@@ -143,38 +143,38 @@ internal static bool TryGetTargetType(InvocationExpressionSyntax getX, SyntaxNod`
`143`	`143`	`TryGetTargetType(memberAccess.Expression, context, null, out result, out instance);`
`144`	`144`	`}`
`145`	`145`
`146`		`- internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetType, string targetMetadataName, BindingFlags effectiveFlags, IReadOnlyList<ITypeSymbol> types, SyntaxNodeAnalysisContext context, out ISymbol target)`
	`146`	`+ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetType, string targetMetadataName, BindingFlags flags, IReadOnlyList<ITypeSymbol> types, SyntaxNodeAnalysisContext context, out ISymbol target)`
`147`	`147`	`{`
`148`	`148`	`var name = TrimName();`
`149`	`149`	`target = null;`
`150`	`150`	`if (targetType is ITypeParameterSymbol typeParameter)`
`151`	`151`	`{`
`152`	`152`	`if (typeParameter.ConstraintTypes.Length == 0)`
`153`	`153`	`{`
`154`		`- return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, effectiveFlags, types, context, out target);`
	`154`	`+ return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, flags, types, context, out target);`
`155`	`155`	`}`
`156`	`156`
`157`	`157`	`foreach (var constraintType in typeParameter.ConstraintTypes)`
`158`	`158`	`{`
`159`		`- var result = TryGetTarget(getX, constraintType, name, effectiveFlags, types, context, out target);`
	`159`	`+ var result = TryGetTarget(getX, constraintType, name, flags, types, context, out target);`
`160`	`160`	`if (result != GetXResult.NoMatch)`
`161`	`161`	`{`
`162`	`162`	`return result;`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`166`		`- return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, effectiveFlags, types, context, out target);`
	`166`	`+ return TryGetTarget(getX, context.Compilation.GetSpecialType(SpecialType.System_Object), name, flags, types, context, out target);`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`if (getX == KnownSymbol.Type.GetNestedType \|\|`
`170`		`- effectiveFlags.HasFlagFast(BindingFlags.DeclaredOnly) \|\|`
`171`		`- (effectiveFlags.HasFlagFast(BindingFlags.Static) &&`
`172`		`- !effectiveFlags.HasFlagFast(BindingFlags.Instance) &&`
`173`		`- !effectiveFlags.HasFlagFast(BindingFlags.FlattenHierarchy)))`
	`170`	`+ flags.HasFlagFast(BindingFlags.DeclaredOnly) \|\|`
	`171`	`+ (flags.HasFlagFast(BindingFlags.Static) &&`
	`172`	`+ !flags.HasFlagFast(BindingFlags.Instance) &&`
	`173`	`+ !flags.HasFlagFast(BindingFlags.FlattenHierarchy)))`
`174`	`174`	`{`
`175`	`175`	`foreach (var member in targetType.GetMembers(name))`
`176`	`176`	`{`
`177`		`- if (!MatchesFilter(member, targetMetadataName, effectiveFlags, types))`
	`177`	`+ if (!MatchesFilter(member, targetMetadataName, flags, types))`
`178`	`178`	`{`
`179`	`179`	`continue;`
`180`	`180`	`}`
`@@ -209,15 +209,27 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy`
`209`	`209`	`return GetXResult.UseContainingType;`
`210`	`210`	`}`
`211`	`211`
`212`		`- return GetXResult.WrongFlags;`
	`212`	`+ if (target.MetadataName == targetMetadataName &&`
	`213`	`+ !MatchesFilter(target, target.MetadataName, flags, null))`
	`214`	`+ {`
	`215`	`+ return GetXResult.WrongFlags;`
	`216`	`+ }`
	`217`	`+`
	`218`	`+ if (!target.ContainingType.Equals(targetType) &&`
	`219`	`+ (target.IsStatic \|\|`
	`220`	`+ flags.HasFlagFast(BindingFlags.DeclaredOnly)))`
	`221`	`+ {`
	`222`	`+ return GetXResult.WrongFlags;`
	`223`	`+ }`
`213`	`224`	`}`
`214`	`225`
`215`	`226`	`if (IsExplicitImplementation(out target))`
`216`	`227`	`{`
`217`	`228`	`return GetXResult.ExplicitImplementation;`
`218`	`229`	`}`
`219`	`230`
`220`		`- if (!HasVisibleMembers(targetType, effectiveFlags))`
	`231`	`+ if (flags.HasFlagFast(BindingFlags.NonPublic) &&`
	`232`	`+ !targetType.Locations.Any(x => x.IsInSource))`
`221`	`233`	`{`
`222`	`234`	`return GetXResult.Unknown;`
`223`	`235`	`}`
`@@ -230,14 +242,7 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy`
`230`	`242`	`{`
`231`	`243`	`foreach (var member in current.GetMembers(name))`
`232`	`244`	`{`
`233`		`- if (!MatchesFilter(member, targetMetadataName, effectiveFlags, types))`
`234`		`- {`
`235`		`- continue;`
`236`		`- }`
`237`		`-`
`238`		`- if (member.IsStatic &&`
`239`		`- !current.Equals(targetType) &&`
`240`		`- !effectiveFlags.HasFlagFast(BindingFlags.FlattenHierarchy))`
	`245`	`+ if (!MatchesFilter(member, targetMetadataName, flags, types))`
`241`	`246`	`{`
`242`	`247`	`continue;`
`243`	`248`	`}`
`@@ -252,6 +257,13 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy`
`252`	`257`	`return GetXResult.UseContainingType;`
`253`	`258`	`}`
`254`	`259`
	`260`	`+ if (member.IsStatic &&`
	`261`	`+ !current.Equals(targetType) &&`
	`262`	`+ !flags.HasFlagFast(BindingFlags.FlattenHierarchy))`
	`263`	`+ {`
	`264`	`+ return GetXResult.WrongFlags;`
	`265`	`+ }`
	`266`	`+`
`255`	`267`	`if (IsOfWrongType(member))`
`256`	`268`	`{`
`257`	`269`	`return GetXResult.WrongMemberType;`
`@@ -274,15 +286,19 @@ internal static GetXResult TryGetTarget(IMethodSymbol getX, ITypeSymbol targetTy`
`274`	`286`	`{`
`275`	`287`	`if (targetType.TryFindFirstMemberRecursive(name, out target))`
`276`	`288`	`{`
`277`		`- return GetXResult.WrongFlags;`
	`289`	`+ if (target.MetadataName == targetMetadataName &&`
	`290`	`+ !MatchesFilter(target, target.MetadataName, flags, null))`
	`291`	`+ {`
	`292`	`+ return GetXResult.WrongFlags;`
	`293`	`+ }`
`278`	`294`	`}`
`279`	`295`
`280`	`296`	`if (IsExplicitImplementation(out target))`
`281`	`297`	`{`
`282`	`298`	`return GetXResult.ExplicitImplementation;`
`283`	`299`	`}`
`284`	`300`
`285`		`- if (!HasVisibleMembers(targetType, effectiveFlags))`
	`301`	`+ if (!HasVisibleMembers(targetType, flags))`
`286`	`302`	`{`
`287`	`303`	`return GetXResult.Unknown;`
`288`	`304`	`}`