V1.1.1 (#2)

* Corrected owned type argument calculation for nested generic types to ensure the proper number of type arguments is determined.
* Improved detection of explicit interface implementations by excluding compiler-generated bridge methods created for by-ref parameter variations.
* Refactored custom attribute argument handling to properly represent arrays and nested values for reflection-only types.
* Enhanced assembly resolution strategy to prioritize exact version matches when loading assemblies from probe folders.
* Improved qualification of explicitly implemented interface members to eliminate ambiguity between implementing member names and corresponding interface member names.

---------

Co-authored-by: Kambiz Khojasteh <kambiz.khojasteh@gmail.com>

Author: kampute

.github/workflows/main.yml

@@ -22,17 +22,17 @@ jobs:
       with:
         dotnet-version: '8.0.x'
 
-    - name: Install Kampose
-      run: dotnet tool install --global kampose
-
     - name: Restore Dependencies
       run: dotnet restore
 
     - name: Build Solution
       run: dotnet build --no-restore -c Release
 
     - name: Test Solution
-      run: dotnet test --no-restore --verbosity minimal
+      run: dotnet test --no-restore --no-build -c Release --verbosity minimal
+
+    - name: Install Kampose for Documentation Generation
+      run: dotnet tool install --global kampose
 
     - name: Generate Documentation
       run: kampose build

kampose.json

@@ -23,6 +23,7 @@
             ]
         }
     ],
+    "topicHierarchy": "directory",
     "theme": "classic",
     "themeSettings": {
         "projectName": "Kampute.DocToolkit",
@@ -33,6 +34,9 @@
         "pageFooter": "- Copyright © {{now 'yyyy'}} [Kampute](https://kampute.com)\n- Site built with [Kampose](https://kampute.github.io/kampose/).",
         "groupTypesByNamespace": true,
         "showTypeMembersSummary": true,
-        "seeAlsoSubtopics": true
+        "seeAlsoSubtopics": true,
+        "menuItems": [
+          "*"
+        ]
     }
 }

src/Kampute.DocToolkit.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>netstandard2.1</TargetFramework>
     <Title>Kampute.DocDotLib</Title>
     <Description>Provides extensible pipeline for generating .NET API documentation by transforming assembly metadata and XML documentation into structured models, with automatic cross-reference resolution, support for multiple output formats (HTML, Markdown), and integration of conceptual topics.</Description>
-    <Version>1.1.0</Version>
+    <Version>1.1.1</Version>
     <Company>Kampute</Company>
     <Authors>Kambiz Khojasteh</Authors>
     <Copyright>Copyright (c) 2025 Kampute</Copyright>
@@ -15,7 +15,7 @@
     <IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
     <ProduceReferenceAssembly>true</ProduceReferenceAssembly>
     <PackageId>Kampute.DocToolkit</PackageId>
     <PackageTags>reflection xmldoc</PackageTags>

src/Languages/CSharp.Literals.cs

@@ -7,6 +7,7 @@ namespace Kampute.DocToolkit.Languages
 {
     using Kampute.DocToolkit.Metadata;
     using System;
+    using System.Collections.Generic;
     using System.Globalization;
     using System.IO;
     using System.Linq;
@@ -234,5 +235,39 @@ static int CountSetBits(ulong value)
                 return count;
             }
         }
+
+        /// <summary>
+        /// Writes the specified typed value to the <see cref="TextWriter"/>.
+        /// </summary>
+        /// <param name="writer">The <see cref="TextWriter"/> to write to.</param>
+        /// <param name="typedValue">The <see cref="TypedValue"/> to write.</param>
+        /// <param name="linker">The <see cref="MemberDocLinker"/> to use for linking to documentation.</param>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="writer"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentException">Thrown when <paramref name="typedValue"/> does not represent a constant value.</exception>
+        private void WriteTypedValue(TextWriter writer, TypedValue typedValue, MemberDocLinker linker)
+        {
+            if (writer is null)
+                throw new ArgumentNullException(nameof(writer));
+
+            if (typedValue.Value is IEnumerable<TypedValue> values)
+            {
+                writer.Write('[');
+                var needsSeparator = false;
+                foreach (var value in values)
+                {
+                    if (needsSeparator)
+                        writer.Write(", ");
+                    else
+                        needsSeparator = true;
+
+                    WriteTypedValue(writer, value, linker);
+                }
+                writer.Write(']');
+            }
+            else
+            {
+                WriteConstantValue(writer, typedValue.Value, typedValue.Type, linker);
+            }
+        }
     }
 }

src/Languages/CSharp.TypeMembers.cs

@@ -20,21 +20,34 @@ public partial class CSharp
         /// <param name="qualifier">The level of qualification to apply to the member's name.</param>
         /// <param name="linker">A delegate for linking to the documentation of a type or type's member.</param>
         /// <param name="indexerName">The name to use for indexers if <paramref name="member"/> is an indexer property; otherwise, <see langword="null"/>.</param>
+        /// <remarks>
+        /// For explicit interface implementations, when <paramref name="qualifier"/> is <see cref="NameQualifier.None"/>, the interface 
+        /// member name is qualified according to <see cref="CodeStyleOptions.FullyQualifyExplicitInterfaceMemberNames"/>. When 
+        /// <paramref name="qualifier"/> is not <see cref="NameQualifier.None"/>, the implementing type is written first according to 
+        /// the specified <paramref name="qualifier"/>, followed by the fully qualified interface member name.
+        /// <para>
+        /// Constructors have no name written, and indexer properties use the provided <paramref name="indexerName"/> if specified.
+        /// </para>
+        /// </remarks>
         private void WriteTypeMemberName(TextWriter writer, ITypeMember member, NameQualifier qualifier, MemberDocLinker linker, string? indexerName = null)
         {
             if (member is IVirtualTypeMember { IsExplicitInterfaceImplementation: true, ImplementedMember: ITypeMember interfaceMember })
             {
-                member = interfaceMember;
-                if (qualifier is not NameQualifier.Full)
+                if (qualifier != NameQualifier.None)
+                {
+                    WriteTypeSignature(writer, member.DeclaringType, qualifier, linker);
+                    writer.Write(Type.Delimiter);
+                    qualifier = NameQualifier.Full;
+                }
+                else
                 {
                     qualifier = Options.FullyQualifyExplicitInterfaceMemberNames
                         ? NameQualifier.Full
                         : NameQualifier.DeclaringType;
                 }
-            }
 
-            if (qualifier != NameQualifier.None)
-                WriteTypeSignature(writer, member.DeclaringType, qualifier, linker);
+                member = interfaceMember;
+            }
 
             var name = member switch
             {
@@ -43,13 +56,16 @@ private void WriteTypeMemberName(TextWriter writer, ITypeMember member, NameQual
                 _ => member.Name
             };
 
-            if (!string.IsNullOrEmpty(name))
+            if (qualifier != NameQualifier.None)
             {
-                if (qualifier != NameQualifier.None)
-                    writer.Write(Type.Delimiter);
+                WriteTypeSignature(writer, member.DeclaringType, qualifier, linker);
+                if (string.IsNullOrEmpty(name))
+                    return;
 
-                linker(writer, member, name);
+                writer.Write(Type.Delimiter);
             }
+
+            linker(writer, member, name);
         }
 
         #region Constructors

src/Languages/CSharp.cs

@@ -351,15 +351,15 @@ public virtual void WriteAttribute(TextWriter writer, ICustomAttribute attribute
             foreach (var argument in attribute.ConstructorArguments)
             {
                 EnsureCommaBeforeNext();
-                WriteConstantValue(writer, argument.Value, argument.Type, linker);
+                WriteTypedValue(writer, argument, linker);
             }
 
             foreach (var (name, argument) in attribute.NamedArguments)
             {
                 EnsureCommaBeforeNext();
                 writer.Write(name);
                 writer.Write(" = ");
-                WriteConstantValue(writer, argument.Value, argument.Type, linker);
+                WriteTypedValue(writer, argument, linker);
             }
 
             if (anyParameterBefore)

src/Metadata/Adapters/CompositeTypeAdapter.cs

@@ -5,6 +5,7 @@
 
 namespace Kampute.DocToolkit.Metadata.Adapters
 {
+    using Kampute.DocToolkit.Support;
     using System;
     using System.Collections.Generic;
     using System.Linq;
@@ -184,7 +185,7 @@ protected virtual IEnumerable<IOperator> GetOperators() => Reflection
         /// <returns>An enumeration of <see cref="IMethod"/> objects representing the explicit interface methods implemented by the type.</returns>
         protected virtual IEnumerable<IMethod> GetExplicitInterfaceMethods() => Reflection
             .GetMethods(BindingFlags.DeclaredOnly | BindingFlags.NonPublic | BindingFlags.Instance)
-            .Where(m => !m.IsSpecialName && IsExplicitMember(m))
+            .Where(m => !m.IsSpecialName && IsExplicitMethod(m))
             .Select(Assembly.Repository.GetMethodMetadata<IMethod>)
             .OrderBy(m => m.Name, StringComparer.Ordinal)
             .ThenBy(m => m.Parameters.Count);
@@ -249,13 +250,46 @@ protected virtual bool IsVisibleNestedType(Type type)
         /// <summary>
         /// Determines whether a member is an explicit interface implementation.
         /// </summary>
-        /// <param name="member">The member to check.</param>
+        /// <param name="member">The reflection information of the member to check.</param>
         /// <returns><see langword="true"/> if the member is an explicit interface implementation; otherwise, <see langword="false"/>.</returns>
         protected virtual bool IsExplicitMember(MemberInfo member)
         {
             return member is not null
                 && member.Name.IndexOf('.') > 0
                 && !member.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.Runtime.CompilerServices.CompilerGeneratedAttribute");
         }
+
+        /// <summary>
+        /// Determines whether a method is an explicit interface implementation.
+        /// </summary>
+        /// <param name="method">The reflection information of the method to check.</param>
+        /// <returns><see langword="true"/> if the method is an explicit interface implementation; otherwise, <see langword="false"/>.</returns>
+        /// <remarks>
+        /// This method excludes compiler-generated bridge methods for implicit interface implementations with by-ref parameters.
+        /// </remarks>
+        protected virtual bool IsExplicitMethod(MethodInfo method)
+        {
+            if (!IsExplicitMember(method) || !(method.IsPrivate && method.IsFinal && method.IsVirtual))
+                return false;
+
+            // Compiler-generated bridge methods are created for implicit interface implementations
+            // that have by-ref parameters (in, ref, out). Check if any parameter is by-ref.
+            var parameters = method.GetParameters();
+            if (!parameters.Any(p => p.ParameterType.IsByRef))
+                return true; // No by-ref parameters, so it's a user-written explicit implementation
+
+            // Has by-ref parameters - check if there's a public method with the same signature
+            var publicMethod = Reflection.GetMethod
+            (
+                name: method.Name.SubstringAfterLast('.'),
+                bindingAttr: BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance,
+                binder: null,
+                types: [.. parameters.Select(p => p.ParameterType)],
+                modifiers: null
+            );
+
+            // If a public method with the same signature exists, this is a compiler-generated bridge
+            return publicMethod is null;
+        }
     }
 }

src/Metadata/Adapters/CustomAttributeAdapter.cs

@@ -54,13 +54,8 @@ public CustomAttributeAdapter(CustomAttributeData attribute, AttributeTarget tar
             Target = target;
 
             attributeType = new(Native.AttributeType.GetMetadata<IClassType>);
-
-            constructorArguments = new(() => [.. Native.ConstructorArguments.Select(
-                arg => new TypedValue(arg.ArgumentType.GetMetadata(), GetArgumentValue(arg)))]);
-
-            namedArguments = new(() => Native.NamedArguments.ToDictionary(
-                arg => arg.MemberName,
-                arg => new TypedValue(arg.TypedValue.ArgumentType.GetMetadata(), GetArgumentValue(arg.TypedValue))));
+            constructorArguments = new(() => [.. Native.ConstructorArguments.Select(CreateTypedValue)]);
+            namedArguments = new(() => Native.NamedArguments.ToDictionary(arg => arg.MemberName, arg => CreateTypedValue(arg.TypedValue)));
         }
 
         /// <summary>
@@ -90,25 +85,25 @@ public CustomAttributeAdapter(CustomAttributeData attribute, AttributeTarget tar
         public virtual bool Represents(CustomAttributeData reflection) => ReferenceEquals(Native, reflection);
 
         /// <summary>
-        /// Gets the value of the specified argument, handling array arguments appropriately.
+        /// Converts a custom attribute typed argument into a <see cref="TypedValue"/>, handling array arguments 
+        /// by wrapping element values in an array of <see cref="TypedValue"/> instances.
         /// </summary>
-        /// <param name="typedArgument">The argument whose value is to be retrieved.</param>
-        /// <returns>The value of the argument.</returns>
-        protected virtual object? GetArgumentValue(CustomAttributeTypedArgument typedArgument)
+        /// <param name="typedArgument">The typed argument to convert.</param>
+        /// <returns>A <see cref="TypedValue"/> representing the typed argument.</returns>
+        protected virtual TypedValue CreateTypedValue(CustomAttributeTypedArgument typedArgument)
         {
             if (typedArgument.Value is IReadOnlyCollection<CustomAttributeTypedArgument> args)
             {
-                var elementType = typedArgument.ArgumentType.GetElementType() ?? typeof(object);
-                var array = Array.CreateInstance(elementType, args.Count);
+                var values = new TypedValue[args.Count];
 
-                var index = 0;
+                var i = 0;
                 foreach (var arg in args)
-                    array.SetValue(GetArgumentValue(arg), index++);
+                    values[i++] = CreateTypedValue(arg);
 
-                return array;
+                return new(typeof(TypedValue[]).GetMetadata(), values);
             }
 
-            return typedArgument.Value;
+            return new(typedArgument.ArgumentType.GetMetadata(), typedArgument.Value);
         }
     }
 }

src/Metadata/Adapters/GenericCapableTypeAdapter.cs

@@ -174,8 +174,9 @@ protected virtual IEnumerable<IType> GetTypeArguments()
             if (DeclaringType is IGenericCapableType genericCapableDeclaringType)
             {
                 var (offset, count) = genericCapableDeclaringType.OwnGenericParameterRange;
-                ownedOffset += offset + count;
-                ownedCount -= count;
+                var inheritedCount = offset + count;
+                ownedOffset += inheritedCount;
+                ownedCount -= inheritedCount;
             }
 
             return (ownedOffset, ownedCount);

src/Metadata/MetadataUniverse.cs

@@ -146,6 +146,8 @@ public Assembly LoadFromPath(string assemblyPath)
         /// </summary>
         private sealed class FolderAssemblyResolver : MetadataAssemblyResolver
         {
+            private static readonly Version ZeroVersion = new(0, 0, 0, 0);
+
             private readonly PathAssemblyResolver pathResolver;
             private readonly List<string> probeFolders;
             private readonly ConcurrentDictionary<string, Assembly?> cache = new(StringComparer.OrdinalIgnoreCase);
@@ -199,6 +201,7 @@ public FolderAssemblyResolver(IEnumerable<string> assemblyPaths, IEnumerable<str
             private Assembly? FindAssemblyInProbeFolders(MetadataLoadContext context, AssemblyName assemblyName)
             {
                 var fileName = assemblyName.Name! + ".dll";
+                var candidates = new SortedList<Version, string>(Comparer<Version>.Create((a, b) => b.CompareTo(a)));
 
                 foreach (var folder in probeFolders)
                 {
@@ -209,7 +212,10 @@ public FolderAssemblyResolver(IEnumerable<string> assemblyPaths, IEnumerable<str
                         {
                             var foundName = AssemblyName.GetAssemblyName(path);
                             if (AssemblyName.ReferenceMatchesDefinition(assemblyName, foundName))
-                                return context.LoadFromAssemblyPath(path);
+                            {
+                                var version = foundName.Version ?? ZeroVersion;
+                                candidates.TryAdd(version, path);
+                            }
                         }
                         catch
                         {
@@ -218,7 +224,15 @@ public FolderAssemblyResolver(IEnumerable<string> assemblyPaths, IEnumerable<str
                     }
                 }
 
-                return null;
+                if (candidates.Count == 0)
+                    return null;
+
+                // Prioritize exact version match
+                if (assemblyName.Version is not null && candidates.TryGetValue(assemblyName.Version, out var exactPath))
+                    return context.LoadFromAssemblyPath(exactPath);
+
+                // Fall back to highest compatible version
+                return context.LoadFromAssemblyPath(candidates.Values[0]);
             }
         }
     }