重构分析器项目

Author: xljiulang

WebApiClient.Analyzers/AttributeCtorAnalyzer.cs

@@ -5,31 +5,31 @@ namespace WebApiClient.Analyzers
     /// <summary>
     /// 诊断描述器
     /// </summary>
-    static class DiagnosticDescriptors
+    static class Descriptors
     {
         /// <summary>
         /// 特性诊断描述器
         /// </summary>
         public static DiagnosticDescriptor AttributeDescriptor { get; }
-           = Rule("WA1001", "不匹配的特性构造函数", "不支持特性的此构造函数，请使用其它构造函数");
+           = Create("WA1001", "不匹配的特性构造函数", "不支持特性的此构造函数，请使用其它构造函数");
 
         /// <summary>
         /// 方法返回类型诊断描述器
         /// </summary>
         public static DiagnosticDescriptor ReturnTypeDescriptor { get; }
-            = Rule("WA1002", "不支持的返回类型", "返回类型必须为ITask<>或Task<>");
+            = Create("WA1002", "不支持的返回类型", "返回类型必须为ITask<>或Task<>");
 
         /// <summary>
         /// 引用参数诊断描述器
         /// </summary>
         public static DiagnosticDescriptor RefParameterDescriptor { get; }
-            = Rule("WA1003", "不支持的ref/out修饰", "参数不支持ref/out等修饰");
+            = Create("WA1003", "不支持的ref/out修饰", "参数不支持ref/out等修饰");
 
         /// <summary>
         /// 非方法声明诊断描述器
         /// </summary>
-        public static DiagnosticDescriptor NotMethodDefindDescriptor { get; }
-            = Rule("WA1004", "不支持的非方法声明", "不支持的非方法声明，只允许方法的声明");
+        public static DiagnosticDescriptor NotMethodDefindedDescriptor { get; }
+            = Create("WA1004", "不支持的非方法声明", "不支持的非方法声明，只允许方法的声明");
 
         /// <summary>
         /// 创建诊断描述器
@@ -39,7 +39,7 @@ static class DiagnosticDescriptors
         /// <param name="message"></param>
         /// <param name="helpLinkUri"></param>
         /// <returns></returns>
-        private static DiagnosticDescriptor Rule(string id, string title, string message, string helpLinkUri = null)
+        private static DiagnosticDescriptor Create(string id, string title, string message, string helpLinkUri = null)
         {
             const string category = "Error";
             if (string.IsNullOrEmpty(helpLinkUri) == true)
@@ -48,17 +48,5 @@ private static DiagnosticDescriptor Rule(string id, string title, string message
             }
             return new DiagnosticDescriptor(id, title, message, category, DiagnosticSeverity.Error, true, helpLinkUri: helpLinkUri);
         }
-
-        /// <summary>
-        /// 转换为诊断结果
-        /// </summary>
-        /// <param name="diagnosticDescriptor"></param>
-        /// <param name="location"></param>
-        /// <param name="messageArgs"></param>
-        /// <returns></returns>
-        public static Diagnostic ToDiagnostic(this DiagnosticDescriptor diagnosticDescriptor, Location location, params object[] messageArgs)
-        {
-            return Diagnostic.Create(diagnosticDescriptor, location, messageArgs);
-        }
     }
 }

WebApiClient.Analyzers/DiagnosticDescriptors.cs renamed to WebApiClient.Analyzers/Descriptors.cs

@@ -0,0 +1,130 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace WebApiClient.Analyzers.Diagnostics
+{
+    /// <summary>
+    /// 表示特性构造函数诊断器
+    /// </summary>
+    class AttributeDiagnostic : HttpApiDiagnostic
+    {
+        /// <summary>
+        /// /// <summary>
+        /// 获取诊断描述
+        /// </summary>
+        /// </summary>
+        public override DiagnosticDescriptor Descriptor { get; } = Descriptors.AttributeDescriptor;
+
+        /// <summary>
+        /// 特性构造函数诊断器
+        /// </summary>
+        /// <param name="context">上下文</param>
+        public AttributeDiagnostic(HttpApiContext context)
+            : base(context)
+        {
+        }
+
+        /// <summary>
+        /// 返回所有的报告诊断
+        /// </summary>
+        /// <returns></returns>
+        protected override IEnumerable<Diagnostic> GetDiagnostics()
+        {
+            var interfaceSymbol = this.Context.SyntaxNodeContext.SemanticModel.GetDeclaredSymbol(this.Context.HttpApiSyntax);
+            if (interfaceSymbol == null)
+            {
+                yield break;
+            }
+
+            var interfaceAttributes = this.GetInterfaceDiagnosticAttributes(interfaceSymbol);
+            var methodAttributes = this.GetApiMethodSymbols().SelectMany(item => this.GetMethodDiagnosticAttributes(item));
+
+            foreach (var item in interfaceAttributes.Concat(methodAttributes))
+            {
+                var location = item.ApplicationSyntaxReference.GetSyntax().GetLocation();
+                yield return this.CreateDiagnostic(location);
+            }
+        }
+
+
+        /// <summary>
+        /// 获取接口已诊断的特性
+        /// </summary>
+        /// <param name="interfaceSymbol">类型</param>
+        /// <returns></returns>
+        private IEnumerable<AttributeData> GetInterfaceDiagnosticAttributes(ITypeSymbol interfaceSymbol)
+        {
+            foreach (var attribuete in interfaceSymbol.GetAttributes())
+            {
+                if (this.CtorAttribueIsDefind(attribuete, AttributeTargets.Interface) == false)
+                {
+                    yield return attribuete;
+                }
+            }
+        }
+      
+
+        /// <summary>
+        /// 获取方法已诊断的特性
+        /// </summary>
+        /// <param name="methodSymbol">方法</param>
+        /// <returns></returns>
+        private IEnumerable<AttributeData> GetMethodDiagnosticAttributes(IMethodSymbol methodSymbol)
+        {
+            foreach (var methodAttribuete in methodSymbol.GetAttributes())
+            {
+                if (this.CtorAttribueIsDefind(methodAttribuete, AttributeTargets.Method) == false)
+                {
+                    yield return methodAttribuete;
+                }
+            }
+
+            foreach (var parameter in methodSymbol.Parameters)
+            {
+                foreach (var parameterAttribute in parameter.GetAttributes())
+                {
+                    if (this.CtorAttribueIsDefind(parameterAttribute, AttributeTargets.Parameter) == false)
+                    {
+                        yield return parameterAttribute;
+                    }
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// 获取特性声明的AttributeCtorUsageAtribute是否声明了指定目标
+        /// </summary>
+        /// <param name="attributeData"></param>
+        /// <param name="targets">指定目标</param>
+        /// <returns></returns>
+        private bool CtorAttribueIsDefind(AttributeData attributeData, AttributeTargets targets)
+        {
+            var ctorAttributes = attributeData.AttributeConstructor?.GetAttributes();
+            if (ctorAttributes.HasValue == false)
+            {
+                return true;
+            }
+
+            var ctorUsageAttribute = ctorAttributes.Value
+                .FirstOrDefault(item => item.AttributeClass.Equals(this.Context.AttributeCtorUsageAtributeType));
+
+            if (ctorUsageAttribute == null)
+            {
+                return true;
+            }
+
+            var arg = ctorUsageAttribute.ConstructorArguments.FirstOrDefault();
+            if (arg.IsNull == true)
+            {
+                return true;
+            }
+
+            var ctorTargets = (AttributeTargets)arg.Value;
+            return ctorTargets.HasFlag(targets);
+        }
+    }
+}

WebApiClient.Analyzers/Diagnostics/AttributeDiagnostic.cs

@@ -0,0 +1,44 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using System.Collections.Generic;
+
+namespace WebApiClient.Analyzers.Diagnostics
+{
+    /// <summary>
+    /// 表示非方法声明诊断器
+    /// </summary>
+    class NotMethodDefindedDiagnostic : HttpApiDiagnostic
+    {
+        /// <summary>
+        /// /// <summary>
+        /// 获取诊断描述
+        /// </summary>
+        /// </summary>
+        public override DiagnosticDescriptor Descriptor { get; } = Descriptors.NotMethodDefindedDescriptor;
+
+        /// <summary>
+        /// 非方法声明诊断器
+        /// </summary>
+        /// <param name="context">上下文</param>
+        public NotMethodDefindedDiagnostic(HttpApiContext context)
+            : base(context)
+        {
+        }
+
+        /// <summary>
+        /// 返回所有的报告诊断
+        /// </summary>
+        /// <returns></returns>
+        protected override IEnumerable<Diagnostic> GetDiagnostics()
+        {
+            foreach (var member in this.Context.HttpApiSyntax.Members)
+            {
+                if (member.Kind() != SyntaxKind.MethodDeclaration)
+                {
+                    var location = member.GetLocation();
+                    yield return this.CreateDiagnostic(location);
+                }
+            }
+        }
+    }
+}

WebApiClient.Analyzers/Diagnostics/NotMethodDefindedDiagnostic.cs

@@ -0,0 +1,50 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace WebApiClient.Analyzers.Diagnostics
+{
+    /// <summary>
+    /// 表示引用传递参数诊断器
+    /// </summary>
+    class RefParameterDiagnostic : HttpApiDiagnostic
+    {
+        /// <summary>
+        /// /// <summary>
+        /// 获取诊断描述
+        /// </summary>
+        /// </summary>
+        public override DiagnosticDescriptor Descriptor { get; } = Descriptors.RefParameterDescriptor;
+
+        /// <summary>
+        /// 引用传递参数诊断器
+        /// </summary>
+        /// <param name="context">上下文</param>
+        public RefParameterDiagnostic(HttpApiContext context)
+            : base(context)
+        {
+        }
+
+        /// <summary>
+        /// 返回所有的报告诊断
+        /// </summary>
+        /// <returns></returns>
+        protected override IEnumerable<Diagnostic> GetDiagnostics()
+        {
+            foreach (var method in this.GetApiMethodSymbols())
+            {
+                foreach (var parameter in method.Parameters)
+                {
+                    if (parameter.RefKind != RefKind.None)
+                    {
+                        var parameterSyntax = parameter.DeclaringSyntaxReferences.First().GetSyntax() as ParameterSyntax;
+                        var location = parameterSyntax.Modifiers.First().GetLocation();
+                        yield return this.CreateDiagnostic(location);
+                    }
+                }
+            }
+        }
+
+    }
+}

WebApiClient.Analyzers/Diagnostics/RefParameterDiagnostic.cs

@@ -0,0 +1,56 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace WebApiClient.Analyzers.Diagnostics
+{
+    /// <summary>
+    /// 表示返回类型诊断器
+    /// </summary>
+    class ReturnTypeDiagnostic : HttpApiDiagnostic
+    {
+        /// <summary>
+        /// /// <summary>
+        /// 获取诊断描述
+        /// </summary>
+        /// </summary>
+        public override DiagnosticDescriptor Descriptor { get; } = Descriptors.ReturnTypeDescriptor;
+
+        /// <summary>
+        /// 返回类型诊断器
+        /// </summary>
+        /// <param name="context">上下文</param>
+        public ReturnTypeDiagnostic(HttpApiContext context)
+            : base(context)
+        {
+        }
+
+
+        /// <summary>
+        /// 返回所有的报告诊断
+        /// </summary>
+        /// <returns></returns>
+        protected override IEnumerable<Diagnostic> GetDiagnostics()
+        {
+            foreach (var method in this.GetApiMethodSymbols())
+            {
+                var name = method.ReturnType.MetadataName;
+                if (name == "Task`1" || name == "ITask`1")
+                {
+                    continue;
+                }
+
+                var methodSyntax = method.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax() as MethodDeclarationSyntax;
+                if (methodSyntax == null)
+                {
+                    continue;
+                }
+
+                var location = methodSyntax.ReturnType.GetLocation();
+                yield return this.CreateDiagnostic(location);
+            }
+        }
+
+    }
+}