Merge pull request #9 from sharwell/initial-analyzers

Initial analyzers

Author: sharwell

OpenStackNetAnalyzers/OpenStackNetAnalyzers/AssertNullAnalyzer.cs

@@ -0,0 +1,91 @@
+namespace OpenStackNetAnalyzers
+{
+    using System;
+    using System.Collections.Immutable;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class AssertNullAnalyzer : DiagnosticAnalyzer
+    {
+        public const string DiagnosticId = "AssertNull";
+        internal const string Title = "Assert.IsNull and Assert.IsNotNull should only be used with nullable types";
+        internal const string MessageFormat = "'Assert.{0}' should not be used with the value type '{1}'";
+        internal const string Category = "OpenStack.Maintainability";
+        internal const string Description = "Assert.IsNull and Assert.IsNotNull should only be used with nullable types";
+
+        private static DiagnosticDescriptor Descriptor =
+            new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Error, 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.RegisterSyntaxNodeAction(HandleInvocationExpression, SyntaxKind.InvocationExpression);
+        }
+
+        private void HandleInvocationExpression(SyntaxNodeAnalysisContext context)
+        {
+            InvocationExpressionSyntax syntax = (InvocationExpressionSyntax)context.Node;
+            if (syntax.Expression == null || !(syntax.ArgumentList?.Arguments.Count > 0))
+                return;
+
+            SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(syntax.Expression, context.CancellationToken);
+            IMethodSymbol methodSymbol = symbolInfo.Symbol as IMethodSymbol;
+            if (methodSymbol == null)
+                return;
+
+            if (!string.Equals("IsNotNull", methodSymbol.Name, StringComparison.Ordinal)
+                && !string.Equals("IsNull", methodSymbol.Name, StringComparison.Ordinal))
+            {
+                return;
+            }
+
+            var containingType = methodSymbol.ContainingType;
+            if (!string.Equals("Assert", containingType?.Name, StringComparison.Ordinal))
+                return;
+
+            if (syntax.ArgumentList.Arguments[0].NameColon != null)
+                return;
+
+            ExpressionSyntax argumentExpression = syntax.ArgumentList.Arguments[0]?.Expression;
+            if (argumentExpression == null)
+                return;
+
+            TypeInfo typeInfo = context.SemanticModel.GetTypeInfo(argumentExpression);
+            INamedTypeSymbol namedType = typeInfo.Type as INamedTypeSymbol;
+            if (namedType == null)
+                return;
+
+            if (!namedType.IsValueType)
+            {
+                // don't report the diagnostic for reference types
+                return;
+            }
+
+            INamedTypeSymbol originalDefinition = namedType.OriginalDefinition;
+            if (originalDefinition == null
+                || originalDefinition.SpecialType == SpecialType.System_Nullable_T
+                || originalDefinition.SpecialType == SpecialType.System_ValueType
+                || originalDefinition.SpecialType == SpecialType.System_Enum)
+            {
+                // don't report the diagnostic for "special" and nullable value types
+                return;
+            }
+
+            string typeName = namedType.ToMinimalDisplayString(context.SemanticModel, argumentExpression.SpanStart, SymbolDisplayFormat.CSharpErrorMessageFormat);
+            context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation(), methodSymbol.Name, typeName));
+        }
+    }
+}

OpenStackNetAnalyzers/OpenStackNetAnalyzers/DocumentDelegatingApiCallAnalyzer.cs

@@ -0,0 +1,71 @@
+namespace OpenStackNetAnalyzers
+{
+    using System;
+    using System.Collections.Immutable;
+    using System.Linq;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.Diagnostics;
+
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class DocumentDelegatingApiCallAnalyzer : DiagnosticAnalyzer
+    {
+        public const string DiagnosticId = "DocumentDelegatingApiCall";
+        internal const string Title = "Document delegating HTTP API call";
+        internal const string MessageFormat = "Document delegating HTTP API call";
+        internal const string Category = "OpenStack.Documentation";
+        internal const string Description = "Document delegating HTTP API call";
+
+        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.TypeKind != TypeKind.Class)
+                return;
+
+            if (!IsDelegatingHttpApiCall(context, symbol))
+                return;
+
+            if (!string.IsNullOrEmpty(symbol.GetDocumentationCommentXml(cancellationToken: context.CancellationToken)))
+                return;
+
+            var locations = symbol.Locations;
+            context.ReportDiagnostic(Diagnostic.Create(Descriptor, locations.FirstOrDefault(), locations.Skip(1)));
+        }
+
+        private bool IsDelegatingHttpApiCall(SymbolAnalysisContext context, INamedTypeSymbol symbol)
+        {
+            while (symbol != null && symbol.SpecialType != SpecialType.System_Object)
+            {
+                if (symbol.IsGenericType)
+                {
+                    var originalDefinition = symbol.OriginalDefinition;
+                    string fullyQualifiedName = originalDefinition.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+                    if (string.Equals("global::OpenStack.Net.DelegatingHttpApiCall<T>", fullyQualifiedName, StringComparison.Ordinal))
+                        return true;
+                }
+
+                symbol = symbol.BaseType;
+            }
+
+            return false;
+        }
+    }
+}