fix: inherit base members from dependent template specializations

When the base is a dependent template specialization (e.g., `base<T>` in
`template<T> class derived : public base<T>`), `BaseMembersFinalizer`
unconditionally read `SpecializationName::specializationID`, which is
only set for concrete `ClassTemplateSpecializationDecl`s. For dependent
bases, it stays invalid, so the `MRDOCS_CHECK_OR_CONTINUE(baseID)` guard
silently skipped the base and no members were inherited.

The fix falls back to the primary template's ID (`Name::id`) when
`specializationID` is invalid, so a class template derived from a
dependent specialization now picks up the primary's members. Concrete
cases like `derived : public base<int>` still inherit from the implicit
specialization as before.

Closes issue #1176.

Author: gennaroprota

src/lib/Metadata/Finalizers/BaseMembersFinalizer.cpp

@@ -242,12 +242,25 @@ operator()(RecordSymbol& I)
         auto& baseNameType = baseI.Type->asNamed();
         MRDOCS_ASSERT(!baseNameType.Name.valueless_after_move());
         auto& baseName = baseNameType.Name->asName();
+        // `baseName.id` is the primary template's ID. When the base
+        // names a concrete specialization (e.g. `base<int>`) and
+        // `extract-implicit-specializations` is on, we prefer the
+        // implicit specialization's ID so inherited members carry
+        // the substituted types. For a dependent base such as
+        // `base<T>` in `template<T> class derived : public base<T>`,
+        // `specializationID` stays invalid (no `ClassTemplate-
+        // SpecializationDecl` exists in the AST), so we fall back
+        // to the primary's ID and inherit its members with the
+        // primary's template parameter intact.
         SymbolID baseID = baseName.id;
         if (corpus_.config->extractImplicitSpecializations && 
             baseName.isSpecialization())
         {
             auto& baseSpec = baseName.asSpecialization();
-            baseID = baseSpec.specializationID;
+            if (baseSpec.specializationID)
+            {
+                baseID = baseSpec.specializationID;
+            }
         }
         MRDOCS_CHECK_OR_CONTINUE(baseID);
         auto basePtr = corpus_.find(baseID);

test-files/golden-tests/config/inherit-base-members/template-base.adoc

@@ -0,0 +1,236 @@
+= Reference
+:mrdocs:
+
+[#index]
+== Global namespace
+
+=== Types
+
+[cols="1,4"]
+|===
+| Name| Description
+| link:#base-06[`base`] 
+| A class template base.
+| link:#concrete_derived[`concrete_derived`] 
+| A non‐template that inherits from a concrete specialization.
+| link:#derived[`derived`] 
+| A class template that inherits from `base<T>`.
+|===
+
+[#base-06]
+== base
+
+A class template base.
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template<typename T>
+class base;
+----
+
+=== Member Functions
+
+[cols="1,4"]
+|===
+| Name| Description
+| link:#base-06-method[`method`] 
+| A regular member function that should also be inherited.
+| link:#base-06-operator_subs[`operator[]`] 
+| Indexing operator that should be inherited.
+|===
+
+=== Derived Classes
+
+[cols="1,4"]
+|===
+|Name|Description
+
+| link:#concrete_derived[`concrete_derived`]
+| A non‐template that inherits from a concrete specialization.
+| link:#derived[`derived`]
+| A class template that inherits from `base<T>`.
+|===
+
+[#base-06-method]
+== link:#base-06[base]::method
+
+A regular member function that should also be inherited.
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+T&
+method();
+----
+
+[#base-06-operator_subs]
+== link:#base-06[base]::operator[]
+
+Indexing operator that should be inherited.
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+T&
+operator[](int n);
+----
+
+=== Parameters
+
+[cols="1,4"]
+|===
+|Name|Description
+
+| *n*
+| The right operand
+|===
+
+[#concrete_derived]
+== concrete_derived
+
+A non‐template that inherits from a concrete specialization.
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+class concrete_derived
+    : public link:#base-06[base<int>]
+----
+
+=== Base Classes
+
+[cols="1,4"]
+|===
+|Name|Description
+
+| `link:#base-06[base<int>]`
+| A class template base.
+|===
+
+=== Member Functions
+
+[cols=1]
+|===
+| Name
+| link:#concrete_derived-method[`method`] 
+| link:#concrete_derived-operator_subs[`operator[]`] 
+|===
+
+[#concrete_derived-method]
+== link:#concrete_derived[concrete_derived]::method
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+int&
+method();
+----
+
+[#concrete_derived-operator_subs]
+== link:#concrete_derived[concrete_derived]::operator[]
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+int&
+operator[](int n);
+----
+
+[#derived]
+== derived
+
+A class template that inherits from `base<T>`.
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template<typename T>
+class derived
+    : public link:#base-06[base<T>]
+----
+
+=== Base Classes
+
+[cols="1,4"]
+|===
+|Name|Description
+
+| `link:#base-06[base<T>]`
+| A class template base.
+|===
+
+=== Member Functions
+
+[cols="1,4"]
+|===
+| Name| Description
+| link:#derived-method[`method`] 
+| A regular member function that should also be inherited.
+| link:#derived-operator_subs[`operator[]`] 
+| Indexing operator that should be inherited.
+|===
+
+[#derived-method]
+== link:#derived[derived]::method
+
+A regular member function that should also be inherited.
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+T&
+method();
+----
+
+[#derived-operator_subs]
+== link:#derived[derived]::operator[]
+
+Indexing operator that should be inherited.
+
+=== Synopsis
+
+Declared in `<template‐base.cpp>`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+T&
+operator[](int n);
+----
+
+=== Parameters
+
+[cols="1,4"]
+|===
+|Name|Description
+
+| *n*
+| The right operand
+|===
+
+
+[.small]#Created with https://www.mrdocs.com[MrDocs]#

test-files/golden-tests/config/inherit-base-members/template-base.cpp

@@ -0,0 +1,29 @@
+// Reproduces issue #1176: members defined in a class template base do not
+// appear in derived classes that inherit from a specialization of that base.
+//
+// Boost.Multi's `array_ref` derives from `subarray`, and `subarray`'s
+// `operator[]` did not show up on `array_ref`'s documentation page,
+// even with `inherit-base-members: copy-all`.
+
+/// A class template base.
+template <typename T>
+class base
+{
+public:
+    /// Indexing operator that should be inherited.
+    T& operator[](int n);
+
+    /// A regular member function that should also be inherited.
+    T& method();
+};
+
+/// A class template that inherits from `base<T>`.
+template <typename T>
+class derived
+    : public base<T>
+{};
+
+/// A non-template that inherits from a concrete specialization.
+class concrete_derived
+    : public base<int>
+{};