Add CancellationTokenAnalyzer

This analyzer ensures that asynchronous methods (whose name ends with
Async and return a Task) include a CancellationToken parameter.

Fixes #22

Author: sharwell

OpenStackNetAnalyzers/OpenStackNetAnalyzers/CancellationTokenAnalyzer.cs

@@ -0,0 +1,55 @@
+namespace OpenStackNetAnalyzers
+{
+    using System.Collections.Immutable;
+    using System.Linq;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class CancellationTokenAnalyzer : DiagnosticAnalyzer
+    {
+        public const string DiagnosticId = "CancellationToken";
+        internal const string Title = "Asynchronous methods should accept a CancellationToken";
+        internal const string MessageFormat = "Asynchronous methods should accept a CancellationToken";
+        internal const string Category = "OpenStack.Maintainability";
+        internal const string Description = "Asynchronous methods should accept a CancellationToken";
+
+        private static DiagnosticDescriptor Descriptor =
+            new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, description: Description);
+
+        private static readonly ImmutableArray<DiagnosticDescriptor> _supportedDiagnostics =
+            ImmutableArray.Create(Descriptor);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+        {
+            get
+            {
+                return _supportedDiagnostics;
+            }
+        }
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.RegisterSymbolAction(HandleMethod, SymbolKind.Method);
+        }
+
+        private void HandleMethod(SymbolAnalysisContext context)
+        {
+            IMethodSymbol method = (IMethodSymbol)context.Symbol;
+            if (!method.Name.EndsWith("Async"))
+                return;
+
+            if (!method.ReturnType.IsTask())
+                return;
+
+            foreach (IParameterSymbol parameter in method.Parameters)
+            {
+                if (parameter.Type.IsCancellationToken())
+                    return;
+            }
+
+            ImmutableArray<Location> locations = method.Locations;
+            context.ReportDiagnostic(Diagnostic.Create(Descriptor, locations.FirstOrDefault(), locations.Skip(1)));
+        }
+    }
+}

OpenStackNetAnalyzers/OpenStackNetAnalyzers/OpenStackNetAnalyzers.csproj

@@ -33,6 +33,7 @@
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="AssertNullAnalyzer.cs" />
+    <Compile Include="CancellationTokenAnalyzer.cs" />
     <Compile Include="DocumentationSyntaxExtensions.cs" />
     <Compile Include="DocumentDelegatingApiCallAnalyzer.cs" />
     <Compile Include="DocumentDelegatingApiCallCodeFix.cs" />

OpenStackNetAnalyzers/OpenStackNetAnalyzers/TypeSymbolExtensions.cs

@@ -9,6 +9,8 @@ internal static class TypeSymbolExtensions
 
         private const string FullyQualifiedTask = "global::System.Threading.Tasks.Task";
 
+        private const string FullyQualifiedCancellationToken = "global::System.Threading.CancellationToken";
+
         public static bool IsNonNullableValueType(this ITypeSymbol type)
         {
             if (type == null)
@@ -50,20 +52,33 @@ public static bool IsImmutableArray(this ITypeSymbol type)
             return string.Equals(FullyQualifiedImmutableArrayT, originalDefinition.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), StringComparison.Ordinal);
         }
 
-        public static bool IsTask(this INamedTypeSymbol symbol)
+        public static bool IsTask(this ITypeSymbol symbol)
         {
-            while (symbol != null && symbol.SpecialType != SpecialType.System_Object)
+            INamedTypeSymbol namedSymbol = symbol as INamedTypeSymbol;
+            while (namedSymbol != null && namedSymbol.SpecialType != SpecialType.System_Object)
             {
-                if (!symbol.IsGenericType)
+                if (!namedSymbol.IsGenericType)
                 {
-                    if (string.Equals(FullyQualifiedTask, symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), StringComparison.Ordinal))
+                    if (string.Equals(FullyQualifiedTask, namedSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), StringComparison.Ordinal))
                         return true;
                 }
 
-                symbol = symbol.BaseType;
+                namedSymbol = namedSymbol.BaseType;
             }
 
             return false;
         }
+
+        public static bool IsCancellationToken(this ITypeSymbol symbol)
+        {
+            INamedTypeSymbol namedSymbol = symbol as INamedTypeSymbol;
+            if (namedSymbol == null)
+                return false;
+
+            if (namedSymbol.TypeKind != TypeKind.Struct)
+                return false;
+
+            return string.Equals(FullyQualifiedCancellationToken, namedSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), StringComparison.Ordinal);
+        }
     }
 }