include type hierarchy in type checking (Implements)

Author: 6bee

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Changed
 
 - Bump _System.Text.Json_ from 7.0.3 to 8.0.0 (concerns _Aqua.Text.Json_)
+- Include type hierarchy in `Implements` type checking
 
 ### Deprecated
 

src/Aqua/TypeExtensions/TypeExtensions.cs

@@ -156,65 +156,63 @@ private static bool Implements(this Type type, Type interfaceType, Type[][] type
             ? IsAssignableToGenericType(interfaceType, typeArgs)
             : interfaceType.IsAssignableFrom;
 
-        return isAssignableFromSpecifiedInterface(type)
+        return GetTypeHierarchy(type).Any(isAssignableFromSpecifiedInterface)
             || type.GetInterfaces().Any(isAssignableFromSpecifiedInterface);
-    }
 
-    private static Func<Type, bool> IsAssignableToGenericTypeDefinition(Type interfaceTypeInfo, Type[][] typeArgs)
-    {
-        var genericArgumentsCount = interfaceTypeInfo.GetGenericArguments().Length;
+        static IEnumerable<Type> GetTypeHierarchy(Type? t)
+        {
+            while (t is not null)
+            {
+                yield return t;
+                t = t.BaseType;
+            }
+        }
 
-        return i =>
+        static Func<Type, bool> IsAssignableToGenericTypeDefinition(Type interfaceTypeInfo, Type[][] typeArgs)
         {
-            var genericArguments = i.GenericTypeArguments;
-            var isAssignable = i.IsGenericType && genericArguments.Length == genericArgumentsCount;
-            if (isAssignable)
+            return i =>
             {
-                try
+                var isAssignable = false;
+                if (i.IsGenericType)
                 {
-                    isAssignable = interfaceTypeInfo.MakeGenericType(genericArguments).IsAssignableFrom(i);
+                    var typeDef = i.IsGenericTypeDefinition ? i : i.GetGenericTypeDefinition();
+                    isAssignable = typeDef == interfaceTypeInfo;
                 }
-                catch (ArgumentException)
+
+                if (isAssignable)
                 {
-                    // justification:
-                    // https://stackoverflow.com/questions/4864496/checking-if-an-object-meets-a-generic-parameter-constraint/4864565#4864565
-                    isAssignable = false;
+                    typeArgs[0] = i.GenericTypeArguments;
                 }
-            }
 
-            if (isAssignable)
-            {
-                typeArgs[0] = genericArguments;
-            }
-
-            return isAssignable;
-        };
-    }
-
-    private static Func<Type, bool> IsAssignableToGenericType(Type interfaceTypeInfo, Type[][] typeArgs)
-    {
-        var interfaceTypeDefinition = interfaceTypeInfo.GetGenericTypeDefinition();
-        var interfaceGenericArguments = interfaceTypeInfo.GetGenericArguments();
+                return isAssignable;
+            };
+        }
 
-        return i =>
+        static Func<Type, bool> IsAssignableToGenericType(Type interfaceTypeInfo, Type[][] typeArgs)
         {
-            if (i.IsGenericType && !i.IsGenericTypeDefinition)
+            var interfaceTypeDefinition = interfaceTypeInfo.GetGenericTypeDefinition();
+            var interfaceGenericArguments = interfaceTypeInfo.GetGenericArguments();
+
+            return i =>
             {
-                var typeDefinition = i.GetGenericTypeDefinition();
-                if (typeDefinition == interfaceTypeDefinition)
+                if (i.IsGenericType && !i.IsGenericTypeDefinition)
                 {
-                    var genericArguments = i.GetGenericArguments();
-                    var allArgumentsAreAssignable = Enumerable.Range(0, genericArguments.Length - 1)
-                        .All(index => Implements(genericArguments[index], interfaceGenericArguments[index], typeArgs));
-                    if (allArgumentsAreAssignable)
+                    var typeDefinition = i.GetGenericTypeDefinition();
+                    if (typeDefinition == interfaceTypeDefinition)
                     {
-                        return true;
+                        var genericArguments = i.GetGenericArguments();
+                        var allArgumentsAreAssignable = Enumerable.Range(0, genericArguments.Length - 1)
+                            .All(index => Implements(genericArguments[index], interfaceGenericArguments[index], typeArgs));
+                        if (allArgumentsAreAssignable)
+                        {
+                            return true;
+                        }
                     }
                 }
-            }
 
-            return false;
-        };
+                return false;
+            };
+        }
     }
 
     /// <summary>

test/Aqua.Tests/TypeExtensions/When_reflecting_implemented_types.cs

@@ -9,6 +9,7 @@ namespace Aqua.Tests.TypeExtensions;
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
+using System.Runtime.InteropServices;
 using Xunit;
 
 public class When_reflecting_implemented_types
@@ -38,6 +39,10 @@ public class TestQueryable<T> : IQueryable<T>
         IEnumerator IEnumerable.GetEnumerator() => throw new NotImplementedException();
     }
 
+    public class GenericSubClass<TNew, TBase> : TestQueryable<TBase>
+    {
+    }
+
     [Fact]
     public void Should_reflect_base_interface()
     {
@@ -113,4 +118,22 @@ public void Should_reflect_base_class()
 
         result.ShouldBeTrue();
     }
+
+    [Fact]
+    public void Should_reflect_generic_base_class()
+    {
+        var result = typeof(GenericSubClass<int, long>).Implements(typeof(TestQueryable<>), out var generics);
+
+        result.ShouldBeTrue();
+        generics.ShouldHaveSingleItem().ShouldBe(typeof(long));
+    }
+
+    [Fact]
+    public void Should_reflect_generic_base_class_interface()
+    {
+        var result = typeof(GenericSubClass<int, long>).Implements(typeof(IQueryable<>), out var generics);
+
+        result.ShouldBeTrue();
+        generics.ShouldHaveSingleItem().ShouldBe(typeof(long));
+    }
 }