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,14 @@ public static bool TryGetAttributeValue<T>(this AttributeData attribute, string
             }
         }
 
+        public static bool HasAttributeUsageInherited(this AttributeData attribute) =>
+            attribute.AttributeClass.GetAttributes()
+                .Where(x => x.AttributeClass.Is(KnownType.System_AttributeUsageAttribute))
+                .SelectMany(x => x.NamedArguments.Where(x => x.Key == nameof(AttributeUsageAttribute.Inherited)))
+                .Where(x => x.Value is { Kind: TypedConstantKind.Primitive, Type.SpecialType: SpecialType.System_Boolean })
+                .Select(x => (bool?)x.Value.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

@@ -19,6 +19,7 @@
  */
 
 using System.Reflection;
+using static System.Net.WebRequestMethods;
 
 namespace SonarAnalyzer.Helpers
 {
@@ -209,6 +210,40 @@ public static bool IsPubliclyAccessible(this ISymbol symbol)
             symbol?.GetAttributes().Where(a => a.AttributeClass.IsAny(attributeTypes))
             ?? Enumerable.Empty<AttributeData>();
 
+        /// <summary>
+        /// Returns attributes for the symbol by also respecting <see cref="AttributeUsageAttribute.Inherited"/>.
+        /// The returned <see cref="AttributeData"/> is consistent with the results from <see cref="MemberInfo.GetCustomAttributes(bool)"/>.
+        /// </summary>
+        public static IEnumerable<AttributeData> GetAttributesWithInherited(this ISymbol symbol)
+        {
+            foreach (var attribute in symbol.GetAttributes())
+            {
+                yield return attribute;
+            }
+
+            var baseSymbol = BaseSymbol(symbol);
+            while (baseSymbol is not null)
+            {
+                foreach (var attribute in baseSymbol.GetAttributes().Where(x => x.HasAttributeUsageInherited()))
+                {
+                    yield return attribute;
+                }
+
+                baseSymbol = BaseSymbol(baseSymbol);
+            }
+
+            static ISymbol BaseSymbol(ISymbol symbol) =>
+                symbol switch
+                {
+                    INamedTypeSymbol namedType => namedType.BaseType,
+                    IMethodSymbol { OriginalDefinition: { } originalDefinition } method when !method.Equals(originalDefinition) => BaseSymbol(originalDefinition),
+                    IMethodSymbol { OverriddenMethod: { } overridenMethod } => overridenMethod,
+                    // Support for other kinds of symbols needs to be implemented/tested as needed. A full list can be found here:
+                    // https://learn.microsoft.com/dotnet/api/system.attributetargets
+                    _ => 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

@@ -21,6 +21,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Moq;
 using Moq.Protected;
+using SonarAnalyzer.Common;
 using SonarAnalyzer.Extensions;
 
 namespace SonarAnalyzer.UnitTest.Extensions
@@ -141,6 +142,126 @@ public void TryGetAttributeValue_ObjectConversion(object value, Type expectedTyp
             actualValue.Should().Be(value);
         }
 
+        [DataTestMethod]
+        [DataRow(true)]
+        [DataRow(false)]
+        public void HasAttributeUsageInherited_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.HasAttributeUsageInherited();
+            actual.Should().Be(inherited);
+        }
+
+        [TestMethod]
+        public void HasAttributeUsageInherited_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.HasAttributeUsageInherited();
+            actual.Should().Be(true); // The default for Inherited = true
+        }
+
+        [TestMethod]
+        public void HasAttributeUsageInherited_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.HasAttributeUsageInherited();
+            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 HasAttributeUsageInherited_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.HasAttributeUsageInherited();
+            actual.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public void HasAttributeUsageInherited_DuplicateAttributeUsage()
+        {
+            var code = $$"""
+                    using System;
+
+                    [AttributeUsage(AttributeTargets.All, Inherited = true)]
+                    [AttributeUsage(AttributeTargets.All, Inherited = false)] // Compiler error
+                    public class MyAttribute: Attribute
+                    {
+                    }
+
+                    [My]
+                    public class Program
+                    {
+                    }
+                    """;
+            var snippet = new SnippetCompiler(code, ignoreErrors: true, AnalyzerLanguage.CSharp);
+            var attribute = snippet.GetTypeSymbol("Program").GetAttributes().Single(x => x.HasName("MyAttribute"));
+            var actual = attribute.HasAttributeUsageInherited();
+            snippet.GetDiagnostics().Should().ContainEquivalentOf(new { Id = "CS0579" }); // "Duplicate 'AttributeUsage' attribute"
+            actual.Should().BeTrue();
+        }
+
         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.EmitAssembly();
+            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.EmitAssembly();
+            var type = assembly.GetType(className, throwOnError: true);
+            type.GetCustomAttributes(inherit: true).Select(x => x.GetType().Name).Should().BeEquivalentTo(expectedAttributes);
+        }
     }
 }