Inheritance resolver (#28)

Author: a-gubskiy

src/BitzArt.XDoc/DocumentationElements/DocumentationElement.cs

@@ -28,4 +28,9 @@ protected DocumentationElement(XDoc source, XmlNode? node)
         Source = source;
         Node = node;
     }
+
+    /// <summary>
+    /// Gets the text content of the XML node.
+    /// </summary>
+    public string Text => Node?.InnerText.Trim() ?? string.Empty;
 }

src/BitzArt.XDoc/DocumentationElements/MemberDocumentation.cs

@@ -17,7 +17,7 @@ public abstract class MemberDocumentation<TMemberInfo> : DocumentationElement, I
 
     TMemberInfo IDocumentationElement<TMemberInfo>.Target => Member;
 
-    internal MemberDocumentation(XDoc source, TMemberInfo member, XmlNode node)
+    internal MemberDocumentation(XDoc source, TMemberInfo member, XmlNode? node)
         : base(source, node)
     {
         Member = member;
@@ -30,20 +30,20 @@ internal MemberDocumentation(XDoc source, TMemberInfo member, XmlNode node)
 /// <inheritdoc/>
 public sealed class FieldDocumentation : MemberDocumentation<FieldInfo>
 {
-    internal FieldDocumentation(XDoc source, FieldInfo field, XmlNode node)
+    internal FieldDocumentation(XDoc source, FieldInfo field, XmlNode? node)
         : base(source, field, node) { }
 }
 
 /// <inheritdoc/>
 public sealed class MethodDocumentation : MemberDocumentation<MethodInfo>
 {
-    internal MethodDocumentation(XDoc source, MethodInfo method, XmlNode node)
+    internal MethodDocumentation(XDoc source, MethodInfo method, XmlNode? node)
         : base(source, method, node) { }
 }
 
 /// <inheritdoc/>
 public sealed class PropertyDocumentation : MemberDocumentation<PropertyInfo>
 {
-    internal PropertyDocumentation(XDoc source, PropertyInfo property, XmlNode node)
+    internal PropertyDocumentation(XDoc source, PropertyInfo property, XmlNode? node)
         : base(source, property, node) { }
 }

src/BitzArt.XDoc/DocumentationElements/TypeDocumentation.cs

@@ -6,27 +6,23 @@ namespace BitzArt.XDoc;
 /// <summary>
 /// Holds information about documentation of a <see cref="System.Type"/>.
 /// </summary>
-public sealed class TypeDocumentation : DocumentationElement, IDocumentationElement<Type>
+public sealed class TypeDocumentation : MemberDocumentation<Type>, IDocumentationElement<Type>
 {
     private readonly Dictionary<MemberInfo, DocumentationElement> _memberData;
 
     /// <summary>
-    /// The <see cref="Type"/> this documentation if provided for.
+    /// The Type this documentation if provided for.
     /// </summary>
-    public Type Type { get; private init; }
-
-    Type IDocumentationElement<Type>.Target => Type;
+    public Type Type => Member;
 
     /// <summary>
     /// List of members declared by this <see cref="Type"/>.
     /// </summary>
     internal IReadOnlyDictionary<MemberInfo, DocumentationElement> MemberData => _memberData.AsReadOnly();
 
     internal TypeDocumentation(XDoc source, Type type, XmlNode? node)
-        : base(source, node)
+        : base(source, type, node)
     {
-        Type = type;
-
         _memberData = [];
     }
 

src/BitzArt.XDoc/XDoc.cs

@@ -30,7 +30,9 @@ public class XDoc
     /// <summary>
     /// Initializes a new instance of the <see cref="XDoc"/> class.
     /// </summary>
-    public XDoc() : this(new()) { }
+    public XDoc() : this(new())
+    {
+    }
 
     internal XDoc(ConcurrentDictionary<Assembly, AssemblyDocumentation> fetchedAssemblies)
     {
@@ -115,6 +117,10 @@ private AssemblyDocumentation Fetch(Assembly assembly)
     /// </summary>
     /// <param name="memberInfo"></param>
     /// <returns></returns>
-    public DocumentationElement? Get(MemberInfo memberInfo)
-        => Get(memberInfo.DeclaringType!)?.GetDocumentation(memberInfo);
+    public DocumentationElement? Get(MemberInfo memberInfo) =>
+        memberInfo switch
+        {
+            Type type => Get(type),
+            _ => Get(memberInfo.DeclaringType!)?.GetDocumentation(memberInfo)
+        };
 }

src/Render/BitzArt.XDoc.PlainText/Extensions/TypeExtensions.cs

@@ -0,0 +1,15 @@
+namespace BitzArt.XDoc;
+
+/// <summary>
+/// Contains extension methods for <see cref="Type"/>.
+/// </summary>
+internal static class TypeExtensions
+{
+    public static IEnumerable<Type> GetImmediateInterfaces(this Type type)
+    {
+        var inheritedInterfaces = type.GetInterfaces().SelectMany(i => i.GetInterfaces()).ToList();
+        inheritedInterfaces.AddRange(type.BaseType?.GetInterfaces() ?? []);
+
+        return type.GetInterfaces().Except(inheritedInterfaces);
+    }
+}

src/Render/BitzArt.XDoc.PlainText/InheritanceResolver.cs

@@ -0,0 +1,125 @@
+using System.Reflection;
+using System.Xml;
+
+namespace BitzArt.XDoc;
+
+/// <summary>
+/// Direct inheritance resolver (<c>&lt;inheritdoc/&gt;</c>)
+/// </summary>
+internal static class InheritanceResolver
+{
+    public static MemberInfo? GetTargetMember(MemberInfo sourceMember, XmlNode? node)
+    {
+        return sourceMember switch
+        {
+            Type type => FindTargetType(type),
+            _ => FindTargetMember(sourceMember.DeclaringType!, sourceMember, false)
+        };
+    }
+
+    private static MemberInfo? FindTargetType(Type type)
+    {
+        if (type.BaseType is not null)
+        {
+            return type.BaseType;
+        }
+
+        return type.GetImmediateInterfaces().FirstOrDefault();
+    }
+
+    private static MemberInfo? FindTargetMember(Type type, MemberInfo sourceMember, bool checkOwnMembers = false)
+    {
+        if (checkOwnMembers)
+        {
+            if (CheckPresence(type, sourceMember, out var found))
+            {
+                return found;
+            }
+        }
+
+        if (type.BaseType != null)
+        {
+            if (CheckPresence(type.BaseType, sourceMember, out var foundInBaseType))
+            {
+                return foundInBaseType;
+            }
+            
+            var result = FindTargetMember(type.BaseType, sourceMember, true);
+
+            if (result is not null)
+            {
+                return result;
+            }
+        }
+
+        foreach (var immediateInterface in type.GetImmediateInterfaces())
+        {
+            if (CheckPresence(immediateInterface, sourceMember, out var found))
+            {
+                return found;
+            }
+        
+            var result = FindTargetMember(immediateInterface, sourceMember, true);
+
+            if (result is not null)
+            {
+                return result;
+            }
+        }
+
+        return null;
+    }
+
+    private static bool CheckPresence(Type type, MemberInfo sourceMember, out MemberInfo? found)
+    {
+        var memberInfos = type.GetMembers();
+
+        foreach (var member in memberInfos)
+        {
+            if (member.MemberType != sourceMember.MemberType)
+            {
+                continue;
+            }
+
+            if (member.Name != sourceMember.Name)
+            {
+                continue;
+            }
+
+            if (sourceMember is MethodInfo sourceMethod && member is MethodInfo targetMethod)
+            {
+                var sourceParams = sourceMethod.GetParameters();
+                var targetParams = targetMethod.GetParameters();
+
+                if (sourceParams.Length != targetParams.Length)
+                {
+                    continue;
+                }
+
+                var parametersMatch = true;
+
+                for (var i = 0; i < sourceParams.Length; i++)
+                {
+                    if (sourceParams[i].ParameterType != targetParams[i].ParameterType)
+                    {
+                        parametersMatch = false;
+                        break;
+                    }
+                }
+
+                if (!parametersMatch)
+                {
+                    continue;
+                }
+            }
+
+            found = member;
+
+            return true;
+        }
+
+        found = null;
+
+        return false;
+    }
+}