infra: improve type comparison (#113)

Author: Meir017

src/FluentAssertions.Analyzers/Tips/Collections/CollectionAnalyzer.cs

@@ -1,15 +1,16 @@
-using Microsoft.CodeAnalysis;
-using System.Linq;
+using FluentAssertions.Analyzers.Utilities;
+using Microsoft.CodeAnalysis;
 
 namespace FluentAssertions.Analyzers
 {
     public abstract class CollectionAnalyzer : FluentAssertionsAnalyzer
     {
         protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel)
         {
-            return type.Name != "String"
-                && type.AllInterfaces.Any(@interface => @interface.Name == "IEnumerable")
-                && !type.AllInterfaces.Any(@interface => @interface.Name == "IDictionary");
+            var iDictionaryType = semanticModel.GetGenericIDictionaryType();
+            return type.SpecialType != SpecialType.System_String
+                && type.IsTypeOrConstructedFromTypeOrImplementsType(SpecialType.System_Collections_Generic_IEnumerable_T)
+                && !type.IsTypeOrConstructedFromTypeOrImplementsType(iDictionaryType);
         }
     }
 }

src/FluentAssertions.Analyzers/Tips/Collections/CollectionShouldHaveElementAt.cs

@@ -1,4 +1,5 @@
-using Microsoft.CodeAnalysis;
+using FluentAssertions.Analyzers.Utilities;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -30,7 +31,10 @@ protected override IEnumerable<FluentAssertionsCSharpSyntaxVisitor> Visitors
 
         protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel)
         {
-            if (type.AllInterfaces.Any(@interface => @interface.Name == "IReadOnlyDictionary" || @interface.Name == "IDictionary"))
+            var iReadOnlyDictionaryType = semanticModel.GetIReadOnlyDictionaryType();
+            var iDictionaryType = semanticModel.GetGenericIDictionaryType();
+            if (type.IsTypeOrConstructedFromTypeOrImplementsType(iReadOnlyDictionaryType)
+                || type.IsTypeOrConstructedFromTypeOrImplementsType(iDictionaryType))
             {
                 return false;
             }

src/FluentAssertions.Analyzers/Tips/Dictionaries/DictionaryAnalyzer.cs

@@ -1,11 +1,14 @@
-using System.Linq;
+using FluentAssertions.Analyzers.Utilities;
 using Microsoft.CodeAnalysis;
 
 namespace FluentAssertions.Analyzers
 {
     public abstract class DictionaryAnalyzer : FluentAssertionsAnalyzer
     {
         protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel)
-            => type.AllInterfaces.Any(@interface => @interface.Name == "IDictionary");
+        {
+            var iDictionaryType = semanticModel.GetGenericIDictionaryType();
+            return type.IsTypeOrConstructedFromTypeOrImplementsType(iDictionaryType);
+        }
     }
 }

src/FluentAssertions.Analyzers/Tips/Exceptions/ExceptionAnalyzer.cs

@@ -1,10 +1,14 @@
-using System;
+using FluentAssertions.Analyzers.Utilities;
 using Microsoft.CodeAnalysis;
 
 namespace FluentAssertions.Analyzers
 {
     public abstract class ExceptionAnalyzer : FluentAssertionsAnalyzer
     {
-        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => type.Name == nameof(Action);
+        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel)
+        {
+            var actionType = semanticModel.GetActionType();
+            return type.IsTypeOrConstructedFromTypeOrImplementsType(actionType);
+        }
     }
 }

src/FluentAssertions.Analyzers/Tips/Strings/StringAnalyzer.cs

@@ -4,6 +4,6 @@ namespace FluentAssertions.Analyzers
 {
     public abstract class StringAnalyzer : FluentAssertionsAnalyzer
     {
-        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => type.Name == "String";
+        protected override bool ShouldAnalyzeVariableType(INamedTypeSymbol type, SemanticModel semanticModel) => type.SpecialType == SpecialType.System_String;
     }
 }

src/FluentAssertions.Analyzers/Utilities/SemanticModelTypeExtensions.cs

@@ -0,0 +1,34 @@
+using Microsoft.CodeAnalysis;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace FluentAssertions.Analyzers.Utilities
+{
+    internal static class SemanticModelTypeExtensions
+    {
+        public static INamedTypeSymbol GetActionType(this SemanticModel semanticModel)
+            => GetTypeFrom(semanticModel, typeof(Action));
+
+        public static INamedTypeSymbol GetGenericIEnumerableType(this SemanticModel semanticModel)
+            => GetTypeFrom(semanticModel, SpecialType.System_Collections_Generic_IEnumerable_T);
+
+        public static INamedTypeSymbol GetIEnumerableType(this SemanticModel semanticModel)
+            => GetTypeFrom(semanticModel, SpecialType.System_Collections_IEnumerable);
+
+        public static INamedTypeSymbol GetIDictionaryType(this SemanticModel semanticModel)
+            => GetTypeFrom(semanticModel, typeof(IDictionary));
+
+        public static INamedTypeSymbol GetGenericIDictionaryType(this SemanticModel semanticModel)
+            => GetTypeFrom(semanticModel, typeof(IDictionary<,>));
+
+        public static INamedTypeSymbol GetIReadOnlyDictionaryType(this SemanticModel semanticModel)
+            => GetTypeFrom(semanticModel, typeof(IReadOnlyDictionary<,>));
+
+        private static INamedTypeSymbol GetTypeFrom(SemanticModel semanticModel, Type type)
+            => semanticModel.Compilation.GetTypeByMetadataName(type.FullName);
+
+        private static INamedTypeSymbol GetTypeFrom(SemanticModel semanticModel, SpecialType type)
+            => semanticModel.Compilation.GetSpecialType(type);
+    }
+}

src/FluentAssertions.Analyzers/Utilities/TypesExtensions.cs

@@ -1,19 +1,23 @@
 using Microsoft.CodeAnalysis;
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace FluentAssertions.Analyzers.Utilities
 {
     internal static class TypesExtensions
     {
-        public static bool IsTypeOrConstructedFromTypeOrImplementsType(this ITypeSymbol type, SpecialType specialType)
+        public static bool IsTypeOrConstructedFromTypeOrImplementsType(this INamedTypeSymbol type, SpecialType specialType)
         {
             var abstractType = type.OriginalDefinition;
             return abstractType.SpecialType == specialType 
                 || abstractType.AllInterfaces.Any(@interface => @interface.OriginalDefinition.SpecialType == specialType);
         }
+
+        public static bool IsTypeOrConstructedFromTypeOrImplementsType(this INamedTypeSymbol type, INamedTypeSymbol other)
+        {
+            var abstractType = type.OriginalDefinition;
+            return abstractType.Equals(other)
+                || abstractType.AllInterfaces.Any(@interface => @interface.OriginalDefinition.Equals(other));
+        }
     }
 }