Add 'AvoidAsyncVoid' analyzer

Fixes #5

Author: sharwell

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/AsyncUsageAnalyzers.Test.csproj

@@ -124,6 +124,7 @@
   <ItemGroup>
     <Compile Include="Naming\AvoidAsyncSuffixUnitTests.cs" />
     <Compile Include="Naming\UseAsyncSuffixUnitTests.cs" />
+    <Compile Include="Reliability\AvoidAsyncVoidUnitTests.cs" />
     <Compile Include="Verifiers\CodeFixVerifier.cs" />
     <Compile Include="Verifiers\DiagnosticVerifier.cs" />
     <Compile Include="Helpers\CodeFixVerifier.Helper.cs" />

AsyncUsageAnalyzers/AsyncUsageAnalyzers.Test/Reliability/AvoidAsyncVoidUnitTests.cs

@@ -0,0 +1,108 @@
+namespace AsyncUsageAnalyzers.Test.Reliability
+{
+    using System.Threading;
+    using System.Threading.Tasks;
+    using AsyncUsageAnalyzers.Reliability;
+    using Microsoft.CodeAnalysis.Diagnostics;
+    using TestHelper;
+    using Xunit;
+
+    public class AvoidAsyncVoidUnitTests : DiagnosticVerifier
+    {
+        [Fact]
+        public async Task TestAsyncReturnVoidAsync()
+        {
+            string testCode = @"
+class ClassName
+{
+    async void MethodNameAsync() { }
+}
+";
+
+            DiagnosticResult expected = CSharpDiagnostic().WithArguments("MethodNameAsync").WithLocation(4, 16);
+            await VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestAsyncEventHandlerReturnVoidAsync()
+        {
+            string testCode = @"
+using System;
+class ClassName
+{
+    ClassName()
+    {
+        AppDomain.CurrentDomain.DomainUnload += MethodNameAsync;
+    }
+
+    async void MethodNameAsync(object sender, EventArgs e) { }
+}
+";
+
+            // This analyzer does not currently handle this case differently from any other method
+            DiagnosticResult expected = CSharpDiagnostic().WithArguments("MethodNameAsync").WithLocation(10, 16);
+            await VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestAsyncReturnTaskAsync()
+        {
+            string testCode = @"
+using System.Threading.Tasks;
+class ClassName
+{
+    async Task MethodNameAsync() { }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestAsyncReturnGenericTaskAsync()
+        {
+            string testCode = @"
+using System.Threading.Tasks;
+class ClassName
+{
+    async Task<int> MethodNameAsync() { return 3; }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestReturnTaskAsync()
+        {
+            string testCode = @"
+using System.Threading.Tasks;
+class ClassName
+{
+    Task MethodNameAsync() { return Task.FromResult(3); }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestReturnGenericTaskAsync()
+        {
+            string testCode = @"
+using System.Threading.Tasks;
+class ClassName
+{
+    Task<int> MethodNameAsync() { return Task.FromResult(3); }
+}
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        protected override DiagnosticAnalyzer GetCSharpDiagnosticAnalyzer()
+        {
+            return new AvoidAsyncVoidAnalyzer();
+        }
+    }
+}

AsyncUsageAnalyzers/AsyncUsageAnalyzers/AsyncUsageAnalyzers.csproj

@@ -57,6 +57,7 @@
     <Compile Include="Naming\UseAsyncSuffixCodeFixProvider.cs" />
     <Compile Include="NoCodeFixAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Reliability\AvoidAsyncVoidAnalyzer.cs" />
     <Compile Include="Reliability\ReliabilityResources.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>

AsyncUsageAnalyzers/AsyncUsageAnalyzers/Reliability/AvoidAsyncVoidAnalyzer.cs

@@ -0,0 +1,55 @@
+namespace AsyncUsageAnalyzers.Reliability
+{
+    using System.Collections.Immutable;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    /// <summary>
+    /// This analyzer identifies code using <c>void</c>-returning <see langword="async"/> methods, and reports a
+    /// warning.
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    [NoCodeFix("No clear transformation to correct violations of this rule.")]
+    public class AvoidAsyncVoidAnalyzer : DiagnosticAnalyzer
+    {
+        /// <summary>
+        /// The ID for diagnostics produced by the <see cref="AvoidAsyncVoidAnalyzer"/> analyzer.
+        /// </summary>
+        public const string DiagnosticId = "AvoidAsyncVoid";
+        private static readonly LocalizableString Title = new LocalizableResourceString(nameof(ReliabilityResources.AvoidAsyncVoidTitle), ReliabilityResources.ResourceManager, typeof(ReliabilityResources));
+        private static readonly LocalizableString MessageFormat = new LocalizableResourceString(nameof(ReliabilityResources.AvoidAsyncVoidMessageFormat), ReliabilityResources.ResourceManager, typeof(ReliabilityResources));
+        private static readonly string Category = "AsyncUsage.CSharp.Reliability";
+        private static readonly LocalizableString Description = new LocalizableResourceString(nameof(ReliabilityResources.AvoidAsyncVoidDescription), ReliabilityResources.ResourceManager, typeof(ReliabilityResources));
+        private static readonly string HelpLink = null;
+
+        private static readonly DiagnosticDescriptor Descriptor =
+            new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, true, Description, HelpLink);
+
+        private static readonly ImmutableArray<DiagnosticDescriptor> SupportedDiagnosticsValue =
+            ImmutableArray.Create(Descriptor);
+
+        /// <inheritdoc/>
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+        {
+            get
+            {
+                return SupportedDiagnosticsValue;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override void Initialize(AnalysisContext context)
+        {
+            context.RegisterSymbolAction(HandleMethodDeclaration, SymbolKind.Method);
+        }
+
+        private void HandleMethodDeclaration(SymbolAnalysisContext context)
+        {
+            IMethodSymbol symbol = (IMethodSymbol)context.Symbol;
+            if (!symbol.IsAsync || !symbol.ReturnsVoid)
+                return;
+
+            context.ReportDiagnostic(Diagnostic.Create(Descriptor, symbol.Locations[0], symbol.Name));
+        }
+    }
+}

AsyncUsageAnalyzers/AsyncUsageAnalyzers/Reliability/ReliabilityResources.Designer.cs

@@ -117,4 +117,13 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
+  <data name="AvoidAsyncVoidDescription" xml:space="preserve">
+    <value>Asynchronous methods should return a Task instead of void</value>
+  </data>
+  <data name="AvoidAsyncVoidMessageFormat" xml:space="preserve">
+    <value>Asynchronous method '{0}' should not return void</value>
+  </data>
+  <data name="AvoidAsyncVoidTitle" xml:space="preserve">
+    <value>Avoid async void</value>
+  </data>
 </root>