Merge pull request #90 from Concurrency-Lab/ph-s032-exclude-argumentnullexception

PH_S032: Exclude sub-types

Author: camrein

doc/analyzers/PH_S032.md

@@ -12,7 +12,7 @@ Encapsulate the exceptions in a task using `Task.FromException(...)`.
 ## Options
 
 ```ini
-# A white-space separated list of exception types to not report
+# A white-space separated list of exception types to not report. The sub-types of these types will be excluded too.
 # Format: <type-specifier1> <type-specifier2> ...
 dotnet_diagnostic.PH_S032.exclusions = System.ArgumentException System.NotImplementedException
 ```

src/ParallelHelper.Test/Analyzer/Smells/ThrowsInPotentiallyAsyncMethodAnalyzerTest.cs

@@ -110,5 +110,25 @@ public Task DoWorkAsync(int input) {
         .AddAnalyzerOption("dotnet_diagnostic.PH_S032.exclusions", "System.InvalidOperationException")
         .VerifyDiagnostic();
     }
+
+    [TestMethod]
+    public void DoesNotReportNonAsyncMethodWithAsyncSuffixAndReturningTaskThatUsesThrowsExpressionWithSubTypeOfExcludedType() {
+      const string source = @"
+using System;
+using System.Threading.Tasks;
+
+class Test {
+  private string value;
+
+  public Task<int> DoWorkAsync(string value) {
+    this.value = value ?? throw new ArgumentNullException(nameof(value));
+    return Task.FromResult(value.Length);
+  }
+}";
+      CreateAnalyzerCompilationBuilder()
+        .AddSourceTexts(source)
+        .AddAnalyzerOption("dotnet_diagnostic.PH_S032.exclusions", "System.ArgumentException")
+        .VerifyDiagnostic();
+    }
   }
 }

src/ParallelHelper/Analyzer/Smells/ThrowsInPotentiallyAsyncMethodAnalyzer.cs

@@ -42,7 +42,7 @@ public class ThrowsInPotentiallyAsyncMethodAnalyzer : DiagnosticAnalyzer {
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
     private const string AsyncSuffix = "Async";
-    private const string DefaultExcludedTypes = "System.ArgumentException System.NotImplementedException";
+    private const string DefaultExcludedBaseTypes = "System.ArgumentException System.NotImplementedException";
 
     public override void Initialize(AnalysisContext context) {
       context.EnableConcurrentExecution();
@@ -73,8 +73,10 @@ public override void Analyze() {
         }
       }
 
-      private IEnumerable<string> GetExcludedExceptionTypes() {
-        return Context.Options.GetConfig(Rule, "exclusions", DefaultExcludedTypes).Split();
+      private IEnumerable<ITypeSymbol> GetExcludedExceptionBaseTypes() {
+        return Context.Options.GetConfig(Rule, "exclusions", DefaultExcludedBaseTypes)
+          .Split()
+          .SelectMany(SemanticModel.GetTypesByName);
       }
 
       private bool IsPotentiallyAsyncMethod() {
@@ -89,24 +91,25 @@ private bool ReturnsTaskObject() {
       }
 
       private IEnumerable<SyntaxNode> GetAllThrowsStatementsAndExpressionsInSameActivationFrame() {
-        var excludedExceptionTypes = GetExcludedExceptionTypes().ToArray();
+        var excludedBaseTypes = GetExcludedExceptionBaseTypes().ToArray();
         return Root.DescendantNodesInSameActivationFrame()
           .WithCancellation(CancellationToken)
-          .Where(node => IsThrowsWithoutExcludedType(node, excludedExceptionTypes));
+          .Where(node => IsThrowsWithoutExcludedType(node, excludedBaseTypes));
       }
 
-      private bool IsThrowsWithoutExcludedType(SyntaxNode node, IEnumerable<string> excludedTypes) {
+      private bool IsThrowsWithoutExcludedType(SyntaxNode node, IEnumerable<ITypeSymbol> excludedBaseTypes) {
+        
         return node switch {
-          ThrowStatementSyntax statement => !IsAnyOfType(statement.Expression, excludedTypes),
-          ThrowExpressionSyntax expression => !IsAnyOfType(expression.Expression, excludedTypes),
+          ThrowStatementSyntax statement => !IsAnySubTypeOf(statement.Expression, excludedBaseTypes),
+          ThrowExpressionSyntax expression => !IsAnySubTypeOf(expression.Expression, excludedBaseTypes),
           _ => false
         };
       }
 
-      private bool IsAnyOfType(SyntaxNode node, IEnumerable<string> types) {
+      private bool IsAnySubTypeOf(SyntaxNode node, IEnumerable<ITypeSymbol> types) {
         var nodeType = SemanticModel.GetTypeInfo(node, CancellationToken).Type;
         return nodeType != null
-          && types.Any(type => SemanticModel.IsEqualType(nodeType, type));
+          && types.Any(baseType => baseType.IsBaseTypeOf(nodeType, CancellationToken));
       }
     }
   }

src/ParallelHelper/Extensions/TypeSymbolExtensions.cs

@@ -1,6 +1,7 @@
 using Microsoft.CodeAnalysis;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 
 namespace ParallelHelper.Extensions {
   /// <summary>
@@ -77,5 +78,19 @@ public static IEnumerable<ISymbol> GetAllPublicMembers(this ITypeSymbol type) {
     public static IEnumerable<ISymbol> GetAllMembers(this ITypeSymbol type) {
       return GetAllBaseTypesAndSelf(type).SelectMany(baseType => baseType.GetMembers());
     }
+
+    /// <summary>
+    /// Checks if the given type is a base type of the given type.
+    /// </summary>
+    /// <param name="baseType">The base type to check.</param>
+    /// <param name="subType">The type to check if it's a sub type of the given base type.</param>
+    /// <param name="cancellationToken">A token to stop the check before completion.</param>
+    /// <returns><c>True</c> if the given type is a sub-type of the given base type.</returns>
+    /// <remarks>This check does not include interfaces.</remarks>
+    public static bool IsBaseTypeOf(this ITypeSymbol baseType, ITypeSymbol subType, CancellationToken cancellationToken) {
+      return subType.GetAllBaseTypesAndSelf()
+        .WithCancellation(cancellationToken)
+        .Any(type => baseType.Equals(type, SymbolEqualityComparer.Default));
+    }
   }
 }