Improve inheritance resolver for plaintext render (#29)

Author: a-gubskiy

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

@@ -1,5 +1,4 @@
 using System.Reflection;
-using System.Xml;
 
 namespace BitzArt.XDoc;
 
@@ -8,118 +7,91 @@ namespace BitzArt.XDoc;
 /// </summary>
 internal static class InheritanceResolver
 {
-    public static MemberInfo? GetTargetMember(MemberInfo sourceMember, XmlNode? node)
+    public static MemberInfo? GetTargetMember(MemberInfo sourceMember)
     {
         return sourceMember switch
         {
             Type type => FindTargetType(type),
-            _ => FindTargetMember(sourceMember.DeclaringType!, sourceMember, false)
+            MemberInfo => FindTargetMember(sourceMember.DeclaringType!, sourceMember)
         };
     }
 
-    private static MemberInfo? FindTargetType(Type type)
+    private static Type? FindTargetType(Type type)
     {
         if (type.BaseType is not null)
         {
             return type.BaseType;
         }
 
-        return type.GetImmediateInterfaces().FirstOrDefault();
+        return GetImmediateInterfaces(type).FirstOrDefault();
     }
 
-    private static MemberInfo? FindTargetMember(Type type, MemberInfo sourceMember, bool checkOwnMembers = false)
+    private static MemberInfo? FindTargetMember(Type type, MemberInfo sourceMember)
     {
-        if (checkOwnMembers)
+        // 1. Check base type members
+        if (type.BaseType is not null)
         {
-            if (CheckPresence(type, sourceMember, out var found))
+            if (CheckPresence(type.BaseType, sourceMember, out var foundInBaseType))
             {
-                return found;
+                return foundInBaseType;
             }
         }
 
-        if (type.BaseType != null)
+        // 2. Check own immediate interfaces' members
+        foreach (var immediateInterface in GetImmediateInterfaces(type))
         {
-            if (CheckPresence(type.BaseType, sourceMember, out var foundInBaseType))
+            if (CheckPresence(immediateInterface, sourceMember, out var found))
             {
-                return foundInBaseType;
+                return found;
             }
-            
-            var result = FindTargetMember(type.BaseType, sourceMember, true);
+        
+            var result = FindTargetMember(immediateInterface, sourceMember);
 
             if (result is not null)
             {
                 return result;
             }
         }
 
-        foreach (var immediateInterface in type.GetImmediateInterfaces())
+        // 3. Recursively visit base type (if any).
+        if (type.BaseType is not null)
         {
-            if (CheckPresence(immediateInterface, sourceMember, out var found))
-            {
-                return found;
-            }
-        
-            var result = FindTargetMember(immediateInterface, sourceMember, true);
+            var result = FindTargetMember(type.BaseType, sourceMember);
 
             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)
+        found = sourceMember switch
         {
-            if (member.MemberType != sourceMember.MemberType)
-            {
-                continue;
-            }
+            PropertyInfo propertyInfo => type.GetProperty(propertyInfo.Name),
 
-            if (member.Name != sourceMember.Name)
-            {
-                continue;
-            }
+            FieldInfo fieldInfo => type.GetField(fieldInfo.Name),
 
-            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;
-                }
-            }
+            MethodInfo methodInfo => type.GetMethod(
+                methodInfo.Name,
+                methodInfo.GetGenericArguments().Length,
+                [.. methodInfo.GetParameters().Select(p => p.ParameterType)]),
 
-            found = member;
+            _ => throw new NotSupportedException()
+        };
 
-            return true;
-        }
+        return found is not null;
+    }
 
-        found = null;
+    private static IEnumerable<Type> GetImmediateInterfaces(Type type)
+    {
+        var inheritedInterfaces = type.GetInterfaces().SelectMany(i => i.GetInterfaces()).ToList();
+        inheritedInterfaces.AddRange(type.BaseType?.GetInterfaces() ?? []);
 
-        return false;
+        return type.GetInterfaces().Except(inheritedInterfaces);
     }
 }

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

@@ -82,7 +82,7 @@ private string Normalize(string input)
             .Where(o => !string.IsNullOrWhiteSpace(o))
             .ToList();
 
-        var separator = _options.ForceSingleLine ? " " : "\n";
+        var separator = _options.Trim ? " " : "\n";
 
         return string.Join(separator, lines);
     }
@@ -122,24 +122,29 @@ private string RenderXmlElement(XmlElement element, MemberInfo? target)
         if (element.Name == "inheritdoc")
         {
             // Direct inheritance
-            return RenderDirectInheritance(element, target);
+            return RenderDirectInheritance(target);
         }
 
         var builder = new StringBuilder();
 
         foreach (XmlNode child in element.ChildNodes)
         {
-            builder.Append(Render(child, null));
+            builder.Append(Render(child, target));
         }
 
         return builder.ToString();
     }
 
     private string RenderReference(XmlElement element)
     {
-        var cref = new MemberIdentifier(element.Attributes["cref"]!.Value);
+        MemberIdentifier.TryCreate(element.Attributes["cref"]?.Value, out var cref);
 
-        var type = _options.UseShortTypeNames ? cref.ShortType : cref.Type;
+        if (cref == null)
+        {
+            return string.Empty;
+        }
+        
+        var type = _options.RemoveNamespace ? cref.ShortType : cref.Type;
 
         if (cref.IsMember)
         {
@@ -149,14 +154,14 @@ private string RenderReference(XmlElement element)
         return type;
     }
 
-    private string RenderDirectInheritance(XmlElement element, MemberInfo? target)
+    private string RenderDirectInheritance(MemberInfo? target)
     {
         if (target == null)
         {
             return string.Empty;
         }
 
-        var targetMember = InheritanceResolver.GetTargetMember(target, element);
+        var targetMember = InheritanceResolver.GetTargetMember(target);
 
         if (targetMember == null)
         {
@@ -165,6 +170,11 @@ private string RenderDirectInheritance(XmlElement element, MemberInfo? target)
 
         var documentationElement = _xdoc.Get(targetMember);
 
+        if (documentationElement == null)
+        {
+            return RenderDirectInheritance(targetMember);
+        }
+
         return Render(documentationElement);
     }
 }

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

@@ -10,12 +10,10 @@ public record RendererOptions
     /// When set to true, any line breaks in the content will be removed or replaced.
     /// When set to false, the content will maintain its original line structure.
     /// </summary>
-    public bool ForceSingleLine { get; init; } = true;
+    public bool Trim { get; init; } = true;
 
     /// <summary>
-    /// Indicating whether type names should be rendered in their short form.
-    /// When set to true, simple type names will be used (e.g., "string" instead of "System.String").
-    /// When set to false, fully qualified type names will be used.
+    /// Whether to remove the namespace from the type names.
     /// </summary>
-    public bool UseShortTypeNames { get; init; } = true;
+    public bool RemoveNamespace { get; init; } = true;
 }

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

@@ -19,8 +19,8 @@ public static string ToPlainText(this DocumentationElement? documentation)
 
         return new PlainTextRenderer(documentation.Source, new RendererOptions
         {
-            ForceSingleLine = true,
-            UseShortTypeNames = true
+            Trim = true,
+            RemoveNamespace = true
         }).Render(documentation);
     }
 }