New Rule: ExcludeFromCodeCoverage attributes should include a justification

README.md

@@ -12,7 +12,7 @@ languages in [SonarQube](http://www.sonarqube.org/), [SonarCloud](https://sonarc
 
 ## Features
 
-* [380+ C# rules](https://rules.sonarsource.com/csharp) and [170+ VB.​NET rules](https://rules.sonarsource.com/vbnet)
+* [390+ C# rules](https://rules.sonarsource.com/csharp) and [170+ VB.​NET rules](https://rules.sonarsource.com/vbnet)
 * Metrics (cognitive complexity, duplications, number of lines etc.)
 * Import of [test coverage reports](https://community.sonarsource.com/t/9871) from Visual Studio Code Coverage, dotCover, OpenCover, Coverlet, Altcover.
 * Import of third party Roslyn Analyzers results

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

@@ -0,0 +1,33 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2022 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+namespace SonarAnalyzer.Rules.CSharp;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class ExcludeFromCodeCoverageAttributesNeedJustification : ExcludeFromCodeCoverageAttributesNeedJustificationBase<SyntaxKind>
+{
+    protected override ILanguageFacade<SyntaxKind> Language => CSharpFacade.Instance;
+
+    protected override SyntaxNode GetJustificationExpression(SyntaxNode node) =>
+        node is AttributeSyntax { ArgumentList.Arguments: { Count: 1 } arguments }
+            && arguments[0] is { NameEquals.Name.Identifier.ValueText: JustificationPropertyName, Expression: { } expression }
+                ? expression
+                : null;
+}

analyzers/src/SonarAnalyzer.Common/Rules/ExcludeFromCodeCoverageAttributesNeedJustificationBase.cs

@@ -0,0 +1,58 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2022 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+namespace SonarAnalyzer.Rules;
+
+public abstract class ExcludeFromCodeCoverageAttributesNeedJustificationBase<TSyntaxKind> : SonarDiagnosticAnalyzer<TSyntaxKind>
+    where TSyntaxKind : struct
+{
+    private const string DiagnosticId = "S6513";
+
+    /// <summary>"Justification" was added in .Net 5, while ExcludeFromCodeCoverage in netstandard2.0.</summary>
+    protected const string JustificationPropertyName = "Justification";
+
+    protected override string MessageFormat => "Add a justification.";
+
+    protected abstract SyntaxNode GetJustificationExpression(SyntaxNode node);
+
+    protected ExcludeFromCodeCoverageAttributesNeedJustificationBase() : base(DiagnosticId) { }
+
+    protected sealed override void Initialize(SonarAnalysisContext context) =>
+        context.RegisterNodeAction(
+            Language.GeneratedCodeRecognizer,
+            c =>
+            {
+                if (NoJustification(c.Node, c.SemanticModel)
+                    && c.SemanticModel.GetSymbolInfo(c.Node).Symbol is IMethodSymbol attribute
+                    && attribute.IsInType(KnownType.System_Diagnostics_CodeAnalysis_ExcludeFromCodeCoverageAttribute)
+                    && HasJustificationProperty(attribute.ContainingType))
+                {
+                    c.ReportIssue(Diagnostic.Create(Rule, c.Node.GetLocation()));
+                }
+            },
+            Language.SyntaxKind.Attribute);
+
+    private bool NoJustification(SyntaxNode node, SemanticModel model) =>
+        GetJustificationExpression(node) is not { } justification
+        || string.IsNullOrWhiteSpace(Language.FindConstantValue(model, justification) as string);
+
+    private static bool HasJustificationProperty(INamedTypeSymbol symbol) =>
+        symbol.MemberNames.Contains(JustificationPropertyName);
+}

analyzers/src/SonarAnalyzer.VisualBasic/Rules/ExcludeFromCodeCoverageAttributesNeedJustification.cs

@@ -0,0 +1,34 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2022 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+namespace SonarAnalyzer.Rules.VisualBasic;
+
+[DiagnosticAnalyzer(LanguageNames.VisualBasic)]
+public sealed class ExcludeFromCodeCoverageAttributesNeedJustification : ExcludeFromCodeCoverageAttributesNeedJustificationBase<SyntaxKind>
+{
+    protected override ILanguageFacade<SyntaxKind> Language => VisualBasicFacade.Instance;
+
+    protected override SyntaxNode GetJustificationExpression(SyntaxNode node) =>
+        node is AttributeSyntax { ArgumentList.Arguments: { Count: 1 } arguments }
+            && arguments[0] is SimpleArgumentSyntax { Expression: { } } argument
+            && Language.NameComparer.Equals(argument.GetName(), JustificationPropertyName)
+                ? argument.Expression
+                : null;
+}

analyzers/tests/SonarAnalyzer.UnitTest/Rules/ExcludeFromCodeCoverageAttributesNeedJustificationTest.cs

@@ -0,0 +1,63 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2022 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using CS = SonarAnalyzer.Rules.CSharp;
+using VB = SonarAnalyzer.Rules.VisualBasic;
+
+namespace SonarAnalyzer.UnitTest.Rules;
+
+[TestClass]
+public class ExcludeFromCodeCoverageAttributesNeedJustificationTest
+{
+    private readonly VerifierBuilder builderCS = new VerifierBuilder<CS.ExcludeFromCodeCoverageAttributesNeedJustification>();
+    private readonly VerifierBuilder builderVB = new VerifierBuilder<VB.ExcludeFromCodeCoverageAttributesNeedJustification>();
+
+#if NET
+    [TestMethod]
+    public void ExcludeFromCodeCoverageAttributesNeedJustification_OnAssembly_CS() =>
+        builderCS.AddSnippet("[assembly:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] // Noncompliant").Verify();
+
+    [TestMethod]
+    public void ExcludeFromCodeCoverageAttributesNeedJustification_OnAssembly_VB() =>
+        builderVB.AddSnippet("<Assembly:System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage> ' Noncompliant").Verify();
+
+    [TestMethod]
+    public void ExcludeFromCodeCoverageAttributesNeedJustification_CS() =>
+       builderCS.AddPaths("ExcludeFromCodeCoverageAttributesNeedJustification.cs").Verify();
+
+    [TestMethod]
+    public void ExcludeFromCodeCoverageAttributesNeedJustification_CSharp9() =>
+        builderCS.AddPaths("ExcludeFromCodeCoverageAttributesNeedJustification.CSharp9.cs").WithTopLevelStatements().Verify();
+
+    [TestMethod]
+    public void ExcludeFromCodeCoverageAttributesNeedJustification_CSharp10() =>
+        builderCS.AddPaths("ExcludeFromCodeCoverageAttributesNeedJustification.CSharp10.cs").WithOptions(ParseOptionsHelper.FromCSharp10).Verify();
+
+    [TestMethod]
+    public void ExcludeFromCodeCoverageAttributesNeedJustification_VB() =>
+        builderVB.AddPaths("ExcludeFromCodeCoverageAttributesNeedJustification.vb").Verify();
+#endif
+
+#if netframework
+    [TestMethod]
+    public void ExcludeFromCodeCoverageAttributesNeedJustification_IgnoredForNet48() =>
+        builderCS.AddPaths("ExcludeFromCodeCoverageAttributesNeedJustification.net48.cs").Verify();
+#endif
+}

analyzers/tests/SonarAnalyzer.UnitTest/TestCases/ExcludeFromCodeCoverageAttributesNeedJustification.CSharp10.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+class NonCompliant
+{
+    public void Method(IEnumerable<int> collection)
+    {
+        [ExcludeFromCodeCoverage] int Get() => 1; // Noncompliant
+
+        _ = collection.Select([ExcludeFromCodeCoverage] (x) => x + 1); // Noncompliant
+
+        Action a = [ExcludeFromCodeCoverage] () => { }; // Noncompliant
+
+        Action x = true
+            ? ([ExcludeFromCodeCoverage] () => { }) // Noncompliant
+            : [ExcludeFromCodeCoverage] () => { }; // Noncompliant
+
+        Call([ExcludeFromCodeCoverage(Justification = "justification")] (x) => { });
+    }
+
+    private void Call(Action<int> action) => action(1);
+}

analyzers/tests/SonarAnalyzer.UnitTest/TestCases/ExcludeFromCodeCoverageAttributesNeedJustification.CSharp9.cs

@@ -0,0 +1,18 @@
+using System.Diagnostics.CodeAnalysis;
+using System;
+
+[ExcludeFromCodeCoverage] // Noncompliant
+void LocalMethod() { }
+
+[ExcludeFromCodeCoverage] // Noncompliant
+static void StaticLocalMethod() { }
+
+[ExcludeFromCodeCoverage] // Noncompliant {{Add a justification.}}
+public record Record
+{
+    public void Method()
+    {
+        [ExcludeFromCodeCoverage] // Noncompliant
+        static void LocalMethod() { }
+    }
+}

analyzers/tests/SonarAnalyzer.UnitTest/TestCases/ExcludeFromCodeCoverageAttributesNeedJustification.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Diagnostics.CodeAnalysis;
+using Alias = System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverageAttribute;
+
+[ExcludeFromCodeCoverage] // Noncompliant ^2#23 {{Add a justification.}}
+class Noncompliant
+{
+    [ExcludeFromCodeCoverage()] // Noncompliant
+    void WithBrackets() { }
+
+    [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] // Noncompliant
+    void FullyDeclaredNamespace() { }
+
+    [global::System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage] // Noncompliant
+    void GloballyDeclaredNamespace() { }
+
+    [ExcludeFromCodeCoverage(Justification = null)] // Noncompliant
+    void WithNull() { }
+
+    [ExcludeFromCodeCoverage(Justification = "")] // Noncompliant
+    void WithEmptyString() { }
+
+    [ExcludeFromCodeCoverage(Justification = "  ")] // Noncompliant
+    void WithWhiteSpace() { }
+
+    [Alias(Justification = "")] // Noncompliant
+    void WithAlias() { }
+
+    [ExcludeFromCodeCoverage] // Noncompliant
+    [CLSCompliant(false)]
+    uint Multiple() { return 0; }
+
+    [ExcludeFromCodeCoverage, CLSCompliant(false)]
+//   ^^^^^^^^^^^^^^^^^^^^^^^
+    uint Combined() { return 0; }
+
+    [ExcludeFromCodeCoverage] // Noncompliant
+    Noncompliant() { }
+
+    [ExcludeFromCodeCoverage] // Noncompliant
+    void Method() { }
+
+    [ExcludeFromCodeCoverage] // Noncompliant
+    event EventHandler Event;
+}
+
+interface IInterface
+{
+    [ExcludeFromCodeCoverage] // Noncompliant
+    void Method();
+}
+
+[ExcludeFromCodeCoverage] // Noncompliant
+struct ProgramStruct
+{
+    [ExcludeFromCodeCoverage] // Noncompliant
+    void Method() { }
+}
+
+[ExcludeFromCodeCoverage(Justification = "justification")]
+class Compliant
+{
+    [ExcludeFromCodeCoverage(Justification = "justification")]
+    Compliant() { }
+
+    [ExcludeFromCodeCoverage(Justification = "justification")]
+    void Method() { }
+
+    [ExcludeFromCodeCoverage(Justification = "justification")]
+    string Property { get; set; }
+
+    [ExcludeFromCodeCoverage(Justification = "justification")]
+    event EventHandler Event;
+}
+
+interface IComplaintInterface
+{
+    [ExcludeFromCodeCoverage(Justification = "justification")]
+    void Method();
+}
+
+[ExcludeFromCodeCoverage(Justification = "justification")]
+struct ComplaintStruct
+{
+    [ExcludeFromCodeCoverage(Justification = "justification")]
+    void Method() { }
+}
+
+class NotApplicable
+{
+    [CLSCompliant(false)]
+    enum Enum { foo, bar }
+
+    NotApplicable() { }
+
+    void Method() { }
+
+    int Property { get; set; }
+
+    int Field;
+
+    event EventHandler Event;
+
+    delegate void Delegate();
+
+    [OtherNamespace.ExcludeFromCodeCoverage]
+    void SameName() { }
+}
+
+namespace OtherNamespace
+{
+    public class ExcludeFromCodeCoverageAttribute : Attribute { }
+}