Add ServiceMethodReturnValueAnalyzer

Fixes #14

Author: sharwell

OpenStackNetAnalyzers/OpenStackNetAnalyzers/OpenStackNetAnalyzers.csproj

@@ -50,6 +50,7 @@
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="SdkTypeSymbolExtensions.cs" />
     <Compile Include="ServiceMethodPrepareAsyncAnalyzer.cs" />
+    <Compile Include="ServiceMethodReturnValueAnalyzer.cs" />
     <Compile Include="SpacingExtensions.cs" />
     <Compile Include="TypeSymbolExtensions.cs" />
     <Compile Include="XmlSyntaxFactory.cs" />

OpenStackNetAnalyzers/OpenStackNetAnalyzers/ServiceMethodReturnValueAnalyzer.cs

@@ -0,0 +1,60 @@
+namespace OpenStackNetAnalyzers
+{
+    using System.Collections.Immutable;
+    using System.Linq;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ServiceMethodReturnValueAnalyzer : DiagnosticAnalyzer
+    {
+        public const string DiagnosticId = "ServiceMethodReturnValue";
+        internal const string Title = "Service interface methods should return a Task<T> with a result that implements IHttpApiCall<T>";
+        internal const string MessageFormat = "Service interface methods should return a Task<T> with a result that implements IHttpApiCall<T>";
+        internal const string Category = "OpenStack.Maintainability";
+        internal const string Description = "Service interface methods should return a Task<T> with a result that implements IHttpApiCall<T>";
+
+        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(HandleNamedType, SymbolKind.NamedType);
+        }
+
+        private void HandleNamedType(SymbolAnalysisContext context)
+        {
+            INamedTypeSymbol symbol = (INamedTypeSymbol)context.Symbol;
+            if (!symbol.IsHttpServiceInterface())
+                return;
+
+            foreach (IMethodSymbol method in symbol.GetMembers().OfType<IMethodSymbol>())
+            {
+                INamedTypeSymbol returnType = method.ReturnType as INamedTypeSymbol;
+                if (returnType.IsTask() && returnType.IsGenericType && returnType.TypeArguments.Length == 1)
+                {
+                    INamedTypeSymbol genericArgument = returnType.TypeArguments[0] as INamedTypeSymbol;
+                    if (genericArgument.IsDelegatingHttpApiCall())
+                    {
+                        // the method returns the expected type
+                        continue;
+                    }
+                }
+
+                ImmutableArray<Location> locations = method.Locations;
+                context.ReportDiagnostic(Diagnostic.Create(Descriptor, locations.FirstOrDefault(), locations.Skip(1)));
+            }
+        }
+    }
+}

OpenStackNetAnalyzers/OpenStackNetAnalyzers/TypeSymbolExtensions.cs

@@ -7,6 +7,8 @@ internal static class TypeSymbolExtensions
     {
         private const string FullyQualifiedImmutableArrayT = "global::System.Collections.Immutable.ImmutableArray<T>";
 
+        private const string FullyQualifiedTask = "global::System.Threading.Tasks.Task";
+
         public static bool IsNonNullableValueType(this ITypeSymbol type)
         {
             if (type == null)
@@ -47,5 +49,21 @@ public static bool IsImmutableArray(this ITypeSymbol type)
 
             return string.Equals(FullyQualifiedImmutableArrayT, originalDefinition.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), StringComparison.Ordinal);
         }
+
+        public static bool IsTask(this INamedTypeSymbol symbol)
+        {
+            while (symbol != null && symbol.SpecialType != SpecialType.System_Object)
+            {
+                if (!symbol.IsGenericType)
+                {
+                    if (string.Equals(FullyQualifiedTask, symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), StringComparison.Ordinal))
+                        return true;
+                }
+
+                symbol = symbol.BaseType;
+            }
+
+            return false;
+        }
     }
 }