Fix S2699 FP: Support overridden methods annotated with AssertionMethodAttribute

analyzers/src/SonarAnalyzer.CSharp/Rules/TestMethodShouldContainAssertion.cs

@@ -152,6 +152,6 @@ private static bool IsTestIgnored(IMethodSymbol method)
             || methodSymbol.ContainingType.DerivesFromAny(KnownAssertionTypes);
 
         private static bool IsCustomAssertion(ISymbol methodSymbol) =>
-            methodSymbol.GetAttributes().Any(x => x.AttributeClass.Name == CustomAssertionAttributeName);
+            methodSymbol.GetAttributesWithInherited().Any(x => x.AttributeClass.Name == CustomAssertionAttributeName);
     }
 }

analyzers/src/SonarAnalyzer.Common/Extensions/AttributeDataExtensions.cs

@@ -46,6 +46,25 @@ public static bool TryGetAttributeValue<T>(this AttributeData attribute, string
             }
         }
 
+        /// <summary>
+        /// Returns the <see cref="AttributeUsageAttribute.Inherited"/> setting for the attribute associated with <paramref name="attribute"/>.
+        /// The returned value is in line with the runtime behavior of <see cref="System.Reflection.MemberInfo.GetCustomAttributes(bool)"/>.
+        /// </summary>
+        /// <param name="attribute">The <see cref="AttributeData"/> of an <see cref="Attribute"/>.</param>
+        /// <returns>
+        /// The <see cref="AttributeUsageAttribute.Inherited"/> value of the <see cref="AttributeUsageAttribute"/> applied to the <paramref name="attribute"/>.
+        /// Returns <see langword="true"/> if no <see cref="AttributeUsageAttribute"/> is applied to the <see cref="Attribute"/> associated with <paramref name="attribute"/>
+        /// as this is the default behavior of <see cref="System.Reflection.MemberInfo.GetCustomAttributes(bool)"/>.
+        /// </returns>
+        public static bool AttributeUsageInherited(this AttributeData attribute) =>
+            attribute.AttributeClass.GetAttributes()
+                .Where(x => x.AttributeClass is { Name: nameof(AttributeUsageAttribute), ContainingNamespace.Name: "System" })
+                .SelectMany(x => x.NamedArguments.Where(x => x.Key == nameof(AttributeUsageAttribute.Inherited)))
+                .Select(x => x.Value)
+                .Where(x => x is { Kind: TypedConstantKind.Primitive, Type.SpecialType: SpecialType.System_Boolean })
+                .Select(x => (bool?)x.Value)
+                .FirstOrDefault() ?? true; // Default value of Inherited is true
+
         private static bool TryConvertConstant<T>(TypedConstant constant, out T value)
         {
             value = default;

analyzers/src/SonarAnalyzer.Common/Helpers/SymbolHelper.cs

@@ -209,6 +209,34 @@ public static bool IsPubliclyAccessible(this ISymbol symbol)
             symbol?.GetAttributes().Where(a => a.AttributeClass.IsAny(attributeTypes))
             ?? Enumerable.Empty<AttributeData>();
 
+        internal static IEnumerable<AttributeData> GetAttributesWithInherited(this ISymbol symbol)
+        {
+            foreach (var attribute in symbol.GetAttributes())
+            {
+                yield return attribute;
+            }
+
+            var baseSymbol = GetBaseSymbol(symbol);
+            while (baseSymbol != null)
+            {
+                foreach (var attribute in baseSymbol.GetAttributes().Where(x => x.AttributeUsageInherited()))
+                {
+                    yield return attribute;
+                }
+
+                baseSymbol = GetBaseSymbol(baseSymbol);
+            }
+
+            static ISymbol GetBaseSymbol(ISymbol symbol) =>
+                symbol switch
+                {
+                    INamedTypeSymbol namedType => namedType.BaseType,
+                    IMethodSymbol { OriginalDefinition: { } originalDefinition } method when !method.Equals(originalDefinition) => GetBaseSymbol(originalDefinition),
+                    IMethodSymbol { IsOverride: true, OverriddenMethod: { } overridenMethod } => overridenMethod,
+                    _ => null,
+                };
+        }
+
         internal static bool AnyAttributeDerivesFrom(this ISymbol symbol, KnownType attributeType) =>
             symbol?.GetAttributes().Any(a => a.AttributeClass.DerivesFrom(attributeType)) ?? false;
 

analyzers/tests/SonarAnalyzer.UnitTest/Extensions/AttributeDataExtensionsTest.cs

@@ -141,6 +141,102 @@ public void TryGetAttributeValue_ObjectConversion(object value, Type expectedTyp
             actualValue.Should().Be(value);
         }
 
+        [DataTestMethod]
+        [DataRow(true)]
+        [DataRow(false)]
+        public void AttributeUsageInherited_InheritedSpecified(bool inherited)
+        {
+            var code = $$"""
+                    using System;
+
+                    [AttributeUsage(AttributeTargets.All, Inherited = {{(inherited ? "true" : "false")}})]
+                    public class MyAttribute: Attribute
+                    {
+                    }
+
+                    [My]
+                    public class Program
+                    {
+                    }
+                    """;
+            var snippet = new SnippetCompiler(code);
+            var attribute = snippet.GetTypeSymbol("Program").GetAttributes().Single(x => x.HasName("MyAttribute"));
+            var actual = attribute.AttributeUsageInherited();
+            actual.Should().Be(inherited);
+        }
+
+        [TestMethod]
+        public void AttributeUsageInherited_InheritedUnSpecified()
+        {
+            var code = $$"""
+                    using System;
+
+                    [AttributeUsage(AttributeTargets.All)]
+                    public class MyAttribute: Attribute
+                    {
+                    }
+
+                    [My]
+                    public class Program
+                    {
+                    }
+                    """;
+            var snippet = new SnippetCompiler(code);
+            var attribute = snippet.GetTypeSymbol("Program").GetAttributes().Single(x => x.HasName("MyAttribute"));
+            var actual = attribute.AttributeUsageInherited();
+            actual.Should().Be(true); // The default for Inherited = true
+        }
+
+        [TestMethod]
+        public void AttributeUsageInherited_NoUsageAttribute()
+        {
+            var code = $$"""
+                    using System;
+
+                    public class MyAttribute: Attribute
+                    {
+                    }
+
+                    [My]
+                    public class Program
+                    {
+                    }
+                    """;
+            var snippet = new SnippetCompiler(code);
+            var attribute = snippet.GetTypeSymbol("Program").GetAttributes().Single(x => x.HasName("MyAttribute"));
+            var actual = attribute.AttributeUsageInherited();
+            actual.Should().Be(true); // The default for Inherited = true
+        }
+
+        [DataTestMethod]
+        [DataRow(true, true)]
+        [DataRow(false, true)] // The "Inherited" flag is not inherited for the AttributeUsage attribute itself. See also the SymbolHelperTest.GetAttributesWithInherited... tests,
+                               // where the reflection behavior of MemberInfo.GetCustomAttributes is also tested.
+        public void AttributeUsageInherited_UsageInherited(bool inherited, bool expected)
+        {
+            var code = $$"""
+                    using System;
+
+                    [AttributeUsage(AttributeTargets.All, Inherited = {{(inherited ? "true" : "false")}})]
+                    public class BaseAttribute: Attribute
+                    {
+                    }
+
+                    public class MyAttribute: BaseAttribute
+                    {
+                    }
+
+                    [My]
+                    public class Program
+                    {
+                    }
+                    """;
+            var snippet = new SnippetCompiler(code);
+            var attribute = snippet.GetTypeSymbol("Program").GetAttributes().Single(x => x.HasName("MyAttribute"));
+            var actual = attribute.AttributeUsageInherited();
+            actual.Should().Be(expected);
+        }
+
         private static AttributeData AttributeDataWithName(string attributeClassName)
         {
             var namedType = new Mock<INamedTypeSymbol>();

analyzers/tests/SonarAnalyzer.UnitTest/Helpers/SymbolHelperTest.cs

@@ -398,5 +398,185 @@ public void GetClassification_Method(MethodKind methodKind, string expected)
 
             fakeSymbol.Object.GetClassification().Should().Be(expected);
         }
+
+        [DataTestMethod]
+        [DataRow("BaseClass`1", "VirtualMethod", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyNotInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedOpenGeneric`1", "VirtualMethod", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedOpenGeneric`1", "NonVirtualMethod")]
+        [DataRow("DerivedOpenGeneric`1", "GenericVirtualMethod`1", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedOpenGeneric`1", "GenericNonVirtualMethod`1")]
+        [DataRow("DerivedClosedGeneric", "VirtualMethod", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedClosedGeneric", "NonVirtualMethod")]
+        [DataRow("DerivedClosedGeneric", "GenericVirtualMethod`1", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedClosedGeneric", "GenericNonVirtualMethod`1")]
+        [DataRow("DerivedNoOverrides`1", "VirtualMethod", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyNotInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedNoOverrides`1", "NonVirtualMethod", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyNotInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedNoOverrides`1", "GenericVirtualMethod`1", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyNotInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedNoOverrides`1", "GenericNonVirtualMethod`1", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyNotInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        public void GetAttributesWithInherited_MethodSymbol(string className, string methodName, params string[] expectedAttributes)
+        {
+            var code = $$"""
+                using System;
+
+                [AttributeUsage(AttributeTargets.All, Inherited = true)]
+                public class MyInheritedAttribute : Attribute { }
+
+                [AttributeUsage(AttributeTargets.All, Inherited = false)]
+                public class MyNotInheritedAttribute : Attribute { }
+
+                public class MyDerivedInheritedAttribute: MyInheritedAttribute { }
+
+                public class MyDerivedNotInheritedAttribute: MyNotInheritedAttribute { }
+
+                public class MyUnannotatedAttribute : Attribute { }
+
+                public class BaseClass<T1>
+                {
+                    [MyInheritedAttribute]
+                    [MyDerivedInheritedAttribute]
+                    [MyNotInherited]
+                    [MyDerivedNotInherited]
+                    [MyUnannotatedAttribute]
+                    public virtual void VirtualMethod() { }
+
+                    [MyInheritedAttribute]
+                    [MyDerivedInheritedAttribute]
+                    [MyNotInherited]
+                    [MyDerivedNotInherited]
+                    [MyUnannotatedAttribute]
+                    public void NonVirtualMethod() { }
+
+                    [MyInheritedAttribute]
+                    [MyDerivedInheritedAttribute]
+                    [MyNotInherited]
+                    [MyDerivedNotInherited]
+                    [MyUnannotatedAttribute]
+                    public void GenericNonVirtualMethod<T2>() { }
+
+                    [MyInheritedAttribute]
+                    [MyDerivedInheritedAttribute]
+                    [MyNotInherited]
+                    [MyDerivedNotInherited]
+                    [MyUnannotatedAttribute]
+                    public virtual void GenericVirtualMethod<T2>() { }
+                }
+
+                public class DerivedOpenGeneric<T1>: BaseClass<T1>
+                {
+                    public override void VirtualMethod() { }
+                    public new void NonVirtualMethod() { }
+                    public new void GenericNonVirtualMethod<T2>() { }
+                    public override void GenericVirtualMethod<T2>() { }
+                }
+
+                public class DerivedClosedGeneric: BaseClass<int>
+                {
+                    public override void VirtualMethod() { }
+                    public new void NonVirtualMethod() { }
+                    public new void GenericNonVirtualMethod<T2>() { }
+                    public override void GenericVirtualMethod<T2>() { }
+                }
+
+                public class DerivedNoOverrides<T>: BaseClass<T>
+                {
+                }
+
+                public class Program
+                {
+                    public static void Main()
+                    {
+                        new {{className.Replace(@"`1", "<int>")}}().{{methodName.Replace(@"`1", "<int>")}}();
+                    }
+                }
+                """;
+            var compiler = new SnippetCompiler(code);
+            var invocationExpression = compiler.GetNodes<InvocationExpressionSyntax>().Should().ContainSingle().Subject;
+            var method = compiler.GetSymbol<IMethodSymbol>(invocationExpression);
+            var actual = method.GetAttributesWithInherited().Select(x => x.AttributeClass.Name).ToList();
+            actual.Should().BeEquivalentTo(expectedAttributes);
+
+            // GetAttributesWithInherited should behave like MemberInfo.GetCustomAttributes from runtime reflection:
+            var assembly = compiler.GetEmittedAssembly();
+            var type = assembly.GetType(className, throwOnError: true);
+            var methodInfo = type.GetMethod(methodName.Replace("`1", string.Empty));
+            methodInfo.GetCustomAttributes(inherit: true).Select(x => x.GetType().Name).Should().BeEquivalentTo(expectedAttributes);
+        }
+
+        [DataTestMethod]
+        [DataRow("BaseClass`1", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyNotInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedOpenGeneric`1", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("DerivedClosedGeneric", "MyInheritedAttribute", "MyDerivedInheritedAttribute", "MyDerivedNotInheritedAttribute", "MyUnannotatedAttribute")]
+        [DataRow("Implement")]
+        public void GetAttributesWithInherited_TypeSymbol(string className, params string[] expectedAttributes)
+        {
+            var code = $$"""
+                using System;
+
+                [AttributeUsage(AttributeTargets.All, Inherited = true)]
+                public class MyInheritedAttribute : Attribute { }
+
+                [AttributeUsage(AttributeTargets.All, Inherited = false)]
+                public class MyNotInheritedAttribute : Attribute { }
+
+                public class MyDerivedInheritedAttribute: MyInheritedAttribute { }
+
+                public class MyDerivedNotInheritedAttribute: MyNotInheritedAttribute { }
+
+                public class MyUnannotatedAttribute : Attribute { }
+
+                [MyInheritedAttribute]
+                [MyDerivedInheritedAttribute]
+                [MyNotInherited]
+                [MyDerivedNotInherited]
+                [MyUnannotatedAttribute]
+                public class BaseClass<T1>
+                {
+                }
+
+                [MyInheritedAttribute]
+                [MyDerivedInheritedAttribute]
+                [MyNotInherited]
+                [MyDerivedNotInherited]
+                [MyUnannotatedAttribute]
+                public interface IInterface
+                {
+                }
+
+                public class DerivedOpenGeneric<T1>: BaseClass<T1>
+                {
+                }
+
+                public class DerivedClosedGeneric: BaseClass<int>
+                {
+                }
+
+                public class Implement: IInterface
+                {
+                }
+
+                public class Program
+                {
+                    public static void Main()
+                    {
+                        new {{className.Replace(@"`1", "<int>")}}();
+                    }
+                }
+                """;
+            var compiler = new SnippetCompiler(code);
+            var objectCreation = compiler.GetNodes<ObjectCreationExpressionSyntax>().Should().ContainSingle().Subject;
+            if (compiler.GetSymbol<IMethodSymbol>(objectCreation) is { MethodKind: MethodKind.Constructor, ReceiverType: { } receiver })
+            {
+                var actual = receiver.GetAttributesWithInherited().Select(x => x.AttributeClass.Name).ToList();
+                actual.Should().BeEquivalentTo(expectedAttributes);
+            }
+            else
+            {
+                Assert.Fail("Constructor could not be found.");
+            }
+            // GetAttributesWithInherited should behave like MemberInfo.GetCustomAttributes from runtime reflection:
+            var assembly = compiler.GetEmittedAssembly();
+            var type = assembly.GetType(className, throwOnError: true);
+            type.GetCustomAttributes(inherit: true).Select(x => x.GetType().Name).Should().BeEquivalentTo(expectedAttributes);
+        }
     }
 }

analyzers/tests/SonarAnalyzer.UnitTest/TestCases/TestMethodShouldContainAssertion.Custom.cs

@@ -64,7 +64,7 @@ public class BaseTest
     public class DerivedTest : BaseTest
     {
         [TestMethod]
-        public void Derived() // Noncompliant FP: The overridden method needs to be annotated because Roslyn does not respect AttributeUsage.Inherited in ISymbol.GetAttributes
+        public void Derived() // Compliant
         {
             CustomAssertionMethod();
         }