From dde8f1b9570b135d58766387f8bf4b829a8c2c77 Mon Sep 17 00:00:00 2001
From: alandefreitas <alandefreitas@gmail.com>
Date: Tue, 14 Jan 2025 16:40:13 -0300
Subject: [PATCH 1/6] attributes template use double brackets

#fix
---
 .../generator/common/partials/symbol/signature/field.hbs    | 2 +-
 .../generator/common/partials/symbol/signature/function.hbs | 2 +-
 test-files/golden-tests/metadata/attributes_1.adoc          | 2 +-
 test-files/golden-tests/metadata/attributes_1.html          | 2 +-
 test-files/golden-tests/metadata/no_unique_address.adoc     | 2 +-
 test-files/golden-tests/metadata/no_unique_address.html     | 2 +-
 test-files/golden-tests/metadata/noreturn.adoc              | 6 +++---
 test-files/golden-tests/metadata/noreturn.html              | 6 +++---
 test-files/golden-tests/snippets/terminate.adoc             | 2 +-
 test-files/golden-tests/snippets/terminate.html             | 2 +-
 10 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/share/mrdocs/addons/generator/common/partials/symbol/signature/field.hbs b/share/mrdocs/addons/generator/common/partials/symbol/signature/field.hbs
index cd4c317b88..adb83e6528 100644
--- a/share/mrdocs/addons/generator/common/partials/symbol/signature/field.hbs
+++ b/share/mrdocs/addons/generator/common/partials/symbol/signature/field.hbs
@@ -1,4 +1,4 @@
-{{#if attributes}}[{{join ", " attributes}}]
+{{#if attributes}}[[{{join ", " attributes}}]]
 {{/if}}
 {{#if isMutable}}mutable
 {{/if~}}
diff --git a/share/mrdocs/addons/generator/common/partials/symbol/signature/function.hbs b/share/mrdocs/addons/generator/common/partials/symbol/signature/function.hbs
index ceb4a159f3..412346c13e 100644
--- a/share/mrdocs/addons/generator/common/partials/symbol/signature/function.hbs
+++ b/share/mrdocs/addons/generator/common/partials/symbol/signature/function.hbs
@@ -2,7 +2,7 @@
 {{/if~}}
 {{#if isFriend}}friend
 {{/if~}}
-{{#if attributes}}{{#unless isFriend}}[{{join ", " attributes}}]
+{{#if attributes}}{{#unless isFriend}}[[{{join ", " attributes}}]]
 {{/unless}}{{/if~}}
 {{#if constexprKind}}{{constexprKind}}
 {{/if~}}
diff --git a/test-files/golden-tests/metadata/attributes_1.adoc b/test-files/golden-tests/metadata/attributes_1.adoc
index 480b2ed11d..6a21d8d78e 100644
--- a/test-files/golden-tests/metadata/attributes_1.adoc
+++ b/test-files/golden-tests/metadata/attributes_1.adoc
@@ -25,7 +25,7 @@ Declared in `&lt;attributes&lowbar;1&period;cpp&gt;`
 
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
-[nodiscard]
+[[nodiscard]]
 bool
 f();
 ----
diff --git a/test-files/golden-tests/metadata/attributes_1.html b/test-files/golden-tests/metadata/attributes_1.html
index e0d7f71722..fcc47a1e8c 100644
--- a/test-files/golden-tests/metadata/attributes_1.html
+++ b/test-files/golden-tests/metadata/attributes_1.html
@@ -32,7 +32,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;attributes_1.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">
-[nodiscard]
+[[nodiscard]]
 bool
 f();
 </code>
diff --git a/test-files/golden-tests/metadata/no_unique_address.adoc b/test-files/golden-tests/metadata/no_unique_address.adoc
index 61f0ccae6e..2395065b95 100644
--- a/test-files/golden-tests/metadata/no_unique_address.adoc
+++ b/test-files/golden-tests/metadata/no_unique_address.adoc
@@ -69,7 +69,7 @@ Declared in `&lt;no&lowbar;unique&lowbar;address&period;cpp&gt;`
 
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
-[deprecated, maybe&lowbar;unused]
+[[deprecated, maybe&lowbar;unused]]
 <<Empty,Empty>> e = Empty&lcub;&rcub;;
 ----
 
diff --git a/test-files/golden-tests/metadata/no_unique_address.html b/test-files/golden-tests/metadata/no_unique_address.html
index db369bac25..4fb80d7bc6 100644
--- a/test-files/golden-tests/metadata/no_unique_address.html
+++ b/test-files/golden-tests/metadata/no_unique_address.html
@@ -80,7 +80,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;no_unique_address.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">
-[deprecated, maybe_unused]
+[[deprecated, maybe_unused]]
 <a href="#Empty">Empty</a> e = Empty{};
 </code>
 </pre>
diff --git a/test-files/golden-tests/metadata/noreturn.adoc b/test-files/golden-tests/metadata/noreturn.adoc
index e90d9c4bf1..c103d8000b 100644
--- a/test-files/golden-tests/metadata/noreturn.adoc
+++ b/test-files/golden-tests/metadata/noreturn.adoc
@@ -74,7 +74,7 @@ Declared in `&lt;noreturn&period;cpp&gt;`
 
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
-[noreturn]
+[[noreturn]]
 static
 void
 f2();
@@ -91,7 +91,7 @@ Declared in `&lt;noreturn&period;cpp&gt;`
 
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
-[noreturn]
+[[noreturn]]
 void
 f3();
 ----
@@ -123,7 +123,7 @@ Declared in `&lt;noreturn&period;cpp&gt;`
 
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
-[noreturn]
+[[noreturn]]
 void
 f1();
 ----
diff --git a/test-files/golden-tests/metadata/noreturn.html b/test-files/golden-tests/metadata/noreturn.html
index 85e6a9f064..5f121220ca 100644
--- a/test-files/golden-tests/metadata/noreturn.html
+++ b/test-files/golden-tests/metadata/noreturn.html
@@ -97,7 +97,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;noreturn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">
-[noreturn]
+[[noreturn]]
 static
 void
 f2();
@@ -115,7 +115,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;noreturn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">
-[noreturn]
+[[noreturn]]
 void
 f3();
 </code>
@@ -149,7 +149,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;noreturn.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">
-[noreturn]
+[[noreturn]]
 void
 f1();
 </code>
diff --git a/test-files/golden-tests/snippets/terminate.adoc b/test-files/golden-tests/snippets/terminate.adoc
index 2d14d8e6e3..5c70c8d359 100644
--- a/test-files/golden-tests/snippets/terminate.adoc
+++ b/test-files/golden-tests/snippets/terminate.adoc
@@ -33,7 +33,7 @@ Declared in `&lt;terminate&period;cpp&gt;`
 
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
-[noreturn]
+[[noreturn]]
 void
 terminate() noexcept;
 ----
diff --git a/test-files/golden-tests/snippets/terminate.html b/test-files/golden-tests/snippets/terminate.html
index 760731a6c2..6ece5e2f05 100644
--- a/test-files/golden-tests/snippets/terminate.html
+++ b/test-files/golden-tests/snippets/terminate.html
@@ -39,7 +39,7 @@ <h3>Synopsis</h3>
 Declared in <code>&lt;terminate.cpp&gt;</code></div>
 <pre>
 <code class="source-code cpp">
-[noreturn]
+[[noreturn]]
 void
 terminate() noexcept;
 </code>

From 7519ab95de47bf2eb08bedcc6e13871b78d2ed39 Mon Sep 17 00:00:00 2001
From: alandefreitas <alandefreitas@gmail.com>
Date: Tue, 14 Jan 2025 16:42:46 -0300
Subject: [PATCH 2/6] extraction mode upgrade checks file filters

#fix
---
 src/lib/AST/ASTVisitor.cpp                  |  3 ++-
 test-files/golden-tests/core/libcxx.adoc    | 13 -------------
 test-files/golden-tests/core/libcxx.html    | 17 -----------------
 test-files/golden-tests/core/libcxx.xml     |  2 --
 test-files/golden-tests/metadata/mrdocs.yml |  2 ++
 test-files/golden-tests/snippets/sqrt.adoc  | 13 -------------
 test-files/golden-tests/snippets/sqrt.html  | 17 -----------------
 test-files/golden-tests/snippets/sqrt.xml   |  2 --
 8 files changed, 4 insertions(+), 65 deletions(-)

diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 54e5b6fbef..86bc41ff74 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -675,7 +675,8 @@ populateInfoBases(InfoTy& I, bool const isNew, DeclTy* D)
     {
         // Try an exact match here
         auto qualifiedName = this->qualifiedName(D);
-        if (checkSymbolFiltersImpl<false>(std::string_view(qualifiedName.str())))
+        if (checkSymbolFiltersImpl<false>(std::string_view(qualifiedName.str())) &&
+            checkFileFilters(D))
         {
             I.Extraction = ExtractionMode::Regular;
             // default mode also becomes regular for its
diff --git a/test-files/golden-tests/core/libcxx.adoc b/test-files/golden-tests/core/libcxx.adoc
index 4f98fa9603..15b1d74179 100644
--- a/test-files/golden-tests/core/libcxx.adoc
+++ b/test-files/golden-tests/core/libcxx.adoc
@@ -5,14 +5,6 @@
 == Global namespace
 
 
-=== Namespaces
-
-[cols=1]
-|===
-| Name 
-
-| <<std,`std`>> 
-|===
 === Functions
 
 [cols=2]
@@ -26,11 +18,6 @@
 
 |===
 
-[#std]
-== std
-
-
-
 [#sqrt]
 == sqrt
 
diff --git a/test-files/golden-tests/core/libcxx.html b/test-files/golden-tests/core/libcxx.html
index df50908d0c..c25e995c44 100644
--- a/test-files/golden-tests/core/libcxx.html
+++ b/test-files/golden-tests/core/libcxx.html
@@ -9,18 +9,6 @@ <h1>Reference</h1>
 <div>
 <h2 id="index">Global namespace</h2>
 </div>
-<h2>Namespaces</h2>
-<table style="table-layout: fixed; width: 100%;">
-<thead>
-<tr>
-<th>Name</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><a href="#std"><code>std</code></a> </td></tr>
-</tbody>
-</table>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
 <thead>
@@ -38,11 +26,6 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="std">std</h2>
-</div>
-</div>
-<div>
-<div>
 <h2 id="sqrt">sqrt</h2>
 <div>
 <p><span>Computes the square root of an integral value.</span></p>
diff --git a/test-files/golden-tests/core/libcxx.xml b/test-files/golden-tests/core/libcxx.xml
index c9ace632b4..21ccb072d4 100644
--- a/test-files/golden-tests/core/libcxx.xml
+++ b/test-files/golden-tests/core/libcxx.xml
@@ -2,8 +2,6 @@
 <mrdocs xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc">
 <namespace id="//////////////////////////8=">
-  <namespace name="std" id="eIvg7iueGIPcE8p1NVfngsp2ojw=">
-  </namespace>
   <template>
     <tparam name="T" class="type"/>
     <function name="sqrt" id="ulFDUE1svTCX8fV/h8EIp4NNbWs=">
diff --git a/test-files/golden-tests/metadata/mrdocs.yml b/test-files/golden-tests/metadata/mrdocs.yml
index eee2ef0cd9..d91e2b2f9e 100644
--- a/test-files/golden-tests/metadata/mrdocs.yml
+++ b/test-files/golden-tests/metadata/mrdocs.yml
@@ -2,3 +2,5 @@
 concurrency: 1
 source-root: .
 single-page: true
+input:
+  - .
diff --git a/test-files/golden-tests/snippets/sqrt.adoc b/test-files/golden-tests/snippets/sqrt.adoc
index 931d91fd1a..4646f46c6b 100644
--- a/test-files/golden-tests/snippets/sqrt.adoc
+++ b/test-files/golden-tests/snippets/sqrt.adoc
@@ -5,14 +5,6 @@
 == Global namespace
 
 
-=== Namespaces
-
-[cols=1]
-|===
-| Name 
-
-| <<std,`std`>> 
-|===
 === Functions
 
 [cols=2]
@@ -26,11 +18,6 @@
 
 |===
 
-[#std]
-== std
-
-
-
 [#sqrt]
 == sqrt
 
diff --git a/test-files/golden-tests/snippets/sqrt.html b/test-files/golden-tests/snippets/sqrt.html
index 464d9bbfcd..6599acb715 100644
--- a/test-files/golden-tests/snippets/sqrt.html
+++ b/test-files/golden-tests/snippets/sqrt.html
@@ -9,18 +9,6 @@ <h1>Reference</h1>
 <div>
 <h2 id="index">Global namespace</h2>
 </div>
-<h2>Namespaces</h2>
-<table style="table-layout: fixed; width: 100%;">
-<thead>
-<tr>
-<th>Name</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td><a href="#std"><code>std</code></a> </td></tr>
-</tbody>
-</table>
 <h2>Functions</h2>
 <table style="table-layout: fixed; width: 100%;">
 <thead>
@@ -38,11 +26,6 @@ <h2>Functions</h2>
 </div>
 <div>
 <div>
-<h2 id="std">std</h2>
-</div>
-</div>
-<div>
-<div>
 <h2 id="sqrt">sqrt</h2>
 <div>
 <p><span>Computes the square root of an integral value.</span></p>
diff --git a/test-files/golden-tests/snippets/sqrt.xml b/test-files/golden-tests/snippets/sqrt.xml
index 6929d29b2b..02350965ba 100644
--- a/test-files/golden-tests/snippets/sqrt.xml
+++ b/test-files/golden-tests/snippets/sqrt.xml
@@ -2,8 +2,6 @@
 <mrdocs xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc">
 <namespace id="//////////////////////////8=">
-  <namespace name="std" id="eIvg7iueGIPcE8p1NVfngsp2ojw=">
-  </namespace>
   <template>
     <tparam name="T" class="type"/>
     <function name="sqrt" id="ulFDUE1svTCX8fV/h8EIp4NNbWs=">

From 80a9509f9276753a32a729f57091a60ebe9f8172 Mon Sep 17 00:00:00 2001
From: alandefreitas <alandefreitas@gmail.com>
Date: Tue, 14 Jan 2025 16:51:38 -0300
Subject: [PATCH 3/6] SFINAE extraction documentation

#docs
---
 docs/mrdocs.schema.json             |   2 +-
 src/lib/AST/ASTVisitor.cpp          | 349 ++++++++++++++++++----------
 src/lib/AST/ASTVisitor.hpp          | 176 +++++++++++---
 src/lib/AST/ClangHelpers.hpp        |  89 ++++++-
 src/lib/AST/TerminalTypeVisitor.hpp | 139 ++++++++++-
 src/lib/Lib/ConfigOptions.json      |   2 +-
 6 files changed, 589 insertions(+), 168 deletions(-)

diff --git a/docs/mrdocs.schema.json b/docs/mrdocs.schema.json
index dde6f3af09..281d139942 100644
--- a/docs/mrdocs.schema.json
+++ b/docs/mrdocs.schema.json
@@ -219,7 +219,7 @@
     },
     "sfinae": {
       "default": true,
-      "description": "When set to true, MrDocs detects SFINAE expressions in the source code and extracts them as part of the documentation. Expressions such as `std::enable_if<...>` are detected, removed, and documented as a requirement.",
+      "description": "When set to true, MrDocs detects SFINAE expressions in the source code and extracts them as part of the documentation. Expressions such as `std::enable_if<...>` are detected, removed, and documented as a requirement. MrDocs uses an algorithm that extracts SFINAE infomation from types by identifying inspecting the primary template and specializations to detect the result type and the controlling expressions in a specialization.",
       "title": "Detect and reduce SFINAE expressions",
       "type": "boolean"
     },
diff --git a/src/lib/AST/ASTVisitor.cpp b/src/lib/AST/ASTVisitor.cpp
index 86bc41ff74..8aecf5e4ac 100644
--- a/src/lib/AST/ASTVisitor.cpp
+++ b/src/lib/AST/ASTVisitor.cpp
@@ -1067,7 +1067,7 @@ populate(
         populate(I.Explicit, D->getExplicitSpecifier());
     }
 
-    ArrayRef<ParmVarDecl*> params = D->parameters();
+    ArrayRef<ParmVarDecl*> const params = D->parameters();
     I.Params.resize(params.size());
     for (std::size_t i = 0; i < params.size(); ++i)
     {
@@ -1101,11 +1101,11 @@ populate(
 
     I.Class = toFunctionClass(D->getDeclKind());
 
-    QualType const RT = D->getReturnType();
-
     // extract the return type in direct dependency mode
     // if it contains a placeholder type which is
     // deduceded as a local class type
+    QualType const RT = D->getReturnType();
+    MRDOCS_SYMBOL_TRACE(RT, context_);
     I.ReturnType = toTypeInfo(RT);
 
     if (auto* TRC = D->getTrailingRequiresClause())
@@ -2084,138 +2084,175 @@ getSourceCode(SourceRange const& R) const
         context_.getLangOpts()).str();
 }
 
-std::optional<std::pair<QualType, std::vector<TemplateArgument>>>
+std::optional<ASTVisitor::SFINAEInfo>
 ASTVisitor::
-isSFINAEType(QualType const T)
+extractSFINAEInfo(QualType const T)
 {
-    if (!config_->sfinae)
-    {
-        return std::nullopt;
-    }
-
-    auto sfinae_info = getSFINAETemplate(T, true);
-    if (!sfinae_info)
-    {
-        return std::nullopt;
-    }
-
-    auto sfinae_result = isSFINAETemplate(
-        sfinae_info->Template, sfinae_info->Member);
+    MRDOCS_SYMBOL_TRACE(T, context_);
+    MRDOCS_CHECK_OR(config_->sfinae, std::nullopt);
 
-    if (!sfinae_result)
-    {
-        return std::nullopt;
-    }
+    // Get the primary template information of the type
+    auto const templateInfo = getSFINAETemplateInfo(T, true);
+    MRDOCS_CHECK_OR(templateInfo, std::nullopt);
 
-    auto [template_params, controlling_params, param_idx] = *sfinae_result;
+    // Find the control parameters for SFINAE
+    auto SFINAEControl = getSFINAEControlParams(*templateInfo);
+    MRDOCS_CHECK_OR(SFINAEControl, std::nullopt);
 
-    auto const Args = sfinae_info->Arguments;
+    // Find the parameter that represents the SFINAE result
+    auto const Args = templateInfo->Arguments;
+    MRDOCS_SYMBOL_TRACE(Args, context_);
     auto const param_arg = tryGetTemplateArgument(
-        template_params, Args, param_idx);
-    if (!param_arg)
-    {
-        return std::nullopt;
-    }
+        SFINAEControl->Parameters, Args, SFINAEControl->ParamIdx);
+    MRDOCS_CHECK_OR(param_arg, std::nullopt);
+    MRDOCS_SYMBOL_TRACE(*param_arg, context_);
 
+    // Create a vector of template arguments that represent the
+    // controlling parameters of the SFINAE template
     std::vector<TemplateArgument> ControllingArgs;
     for (std::size_t I = 0; I < Args.size(); ++I)
     {
-        if (controlling_params[I])
+        if (SFINAEControl->ControllingParams[I])
         {
+            MRDOCS_SYMBOL_TRACE(Args[I], context_);
             ControllingArgs.emplace_back(Args[I]);
         }
     }
 
-    return std::make_pair(param_arg->getAsType(), std::move(ControllingArgs));
+    // Return the main type and controlling types
+    return SFINAEInfo{param_arg->getAsType(), std::move(ControllingArgs)};
 }
 
-std::optional<std::tuple<TemplateParameterList*, llvm::SmallBitVector, unsigned>>
+std::optional<ASTVisitor::SFINAEControlParams>
 ASTVisitor::
-isSFINAETemplate(
+getSFINAEControlParams(
     TemplateDecl* TD,
-    const IdentifierInfo* Member)
+    IdentifierInfo const* Member)
 {
-    if (!TD)
-    {
-        return std::nullopt;
-    }
+    MRDOCS_SYMBOL_TRACE(TD, context_);
+    MRDOCS_SYMBOL_TRACE(Member, context_);
+    MRDOCS_CHECK_OR(TD, std::nullopt);
 
+    // The `FindParam` lambda function is used to find the index of a
+    // template argument in a list of template arguments. It is used
+    // to find the index of the controlling parameter in the list of
+    // template arguments of the template declaration.
     auto FindParam = [this](
         ArrayRef<TemplateArgument> Arguments,
-        const TemplateArgument& Arg) -> unsigned
+        const TemplateArgument& Arg) -> std::size_t
     {
         if (Arg.getKind() != TemplateArgument::Type)
         {
             return -1;
         }
-        auto Found = std::ranges::find_if(Arguments, [&](const TemplateArgument& Other)
-        {
-            if (Other.getKind() != TemplateArgument::Type)
+        auto const It = std::ranges::find_if(
+            Arguments,
+            [&](const TemplateArgument& Other)
             {
-                return false;
-            }
-            return context_.hasSameType(Other.getAsType(), Arg.getAsType());
-        });
-        return Found != Arguments.end() ? Found - Arguments.data() : -1;
+                if (Other.getKind() != TemplateArgument::Type)
+                {
+                    return false;
+                }
+                return context_.hasSameType(Other.getAsType(), Arg.getAsType());
+            });
+        bool const found = It != Arguments.end();
+        return found ? It - Arguments.data() : static_cast<std::size_t>(-1);
     };
 
     if(auto* ATD = dyn_cast<TypeAliasTemplateDecl>(TD))
     {
+        // If the alias template is an alias template specialization,
+        // we need to do the process for the underlying type
+        MRDOCS_SYMBOL_TRACE(ATD, context_);
         auto Underlying = ATD->getTemplatedDecl()->getUnderlyingType();
-        auto sfinae_info = getSFINAETemplate(Underlying, !Member);
-        if (!sfinae_info)
-        {
-            return std::nullopt;
-        }
+        MRDOCS_SYMBOL_TRACE(Underlying, context_);
+        auto underlyingTemplateInfo = getSFINAETemplateInfo(Underlying, Member == nullptr);
+        MRDOCS_CHECK_OR(underlyingTemplateInfo, std::nullopt);
         if (Member)
         {
-            sfinae_info->Member = Member;
-        }
-        auto sfinae_result = isSFINAETemplate(
-            sfinae_info->Template, sfinae_info->Member);
-        if (!sfinae_result)
-        {
-            return std::nullopt;
+            // Get the member specified in the alias type from
+            // the underlying type. If `Member` is `nullptr`,
+            // `getSFINAETemplateInfo` was already allowed to populate
+            // the `Member` field.
+            underlyingTemplateInfo->Member = Member;
         }
-        auto [template_params, controlling_params, param_idx] = *sfinae_result;
+        auto sfinaeControl = getSFINAEControlParams(*underlyingTemplateInfo);
+        MRDOCS_CHECK_OR(sfinaeControl, std::nullopt);
+
+        // Find the index of the parameter that represents the SFINAE result
+        // in the underlying template arguments
         auto param_arg = tryGetTemplateArgument(
-            template_params, sfinae_info->Arguments, param_idx);
-        if (!param_arg)
-        {
-            return std::nullopt;
-        }
+            sfinaeControl->Parameters,
+            underlyingTemplateInfo->Arguments,
+            sfinaeControl->ParamIdx);
+        MRDOCS_CHECK_OR(param_arg, std::nullopt);
+        MRDOCS_SYMBOL_TRACE(*param_arg, context_);
+
+        // Find the index of the parameter that represents the SFINAE result
+        // in the primary template arguments
         unsigned ParamIdx = FindParam(ATD->getInjectedTemplateArgs(context_), *param_arg);
-        return std::make_tuple(ATD->getTemplateParameters(), std::move(controlling_params), ParamIdx);
+
+        // Return the controlling parameters with values corresponding to
+        // the primary template arguments
+        TemplateParameterList* primaryTemplParams = ATD->getTemplateParameters();
+        MRDOCS_SYMBOL_TRACE(primaryTemplParams, context_);
+        return SFINAEControlParams(
+            primaryTemplParams,
+            std::move(sfinaeControl->ControllingParams),
+            ParamIdx);
     }
 
+    // Ensure this is a ClassTemplateDecl
     auto* CTD = dyn_cast<ClassTemplateDecl>(TD);
-    if (!CTD)
-    {
-        return std::nullopt;
-    }
+    MRDOCS_SYMBOL_TRACE(CTD, context_);
+    MRDOCS_CHECK_OR(CTD, std::nullopt);
 
+    // Get the template arguments of the primary template
     auto PrimaryArgs = CTD->getInjectedTemplateArgs(context_);
-    llvm::SmallBitVector ControllingParams(PrimaryArgs.size());
+    MRDOCS_SYMBOL_TRACE(PrimaryArgs, context_);
 
+    // Type of the member that represents the SFINAE result.
     QualType MemberType;
+
+    // Index of the parameter that represents the the SFINAE result.
+    // For instance, in the specialization `std::enable_if<true,T>::type`,
+    // `type` is `T`, which corresponds to the second template parameter
+    // `T`, so `ParamIdx` is `1` to represent the second parameter.
     unsigned ParamIdx = -1;
+
+    // The `IsMismatch` function checks if there's a mismatch between the
+    // CXXRecordDecl of the ClassTemplateDecl and the specified template
+    // arguments. If there's a mismatch and `IsMismatch` returns `true`,
+    // the caller returns `std::nullopt` to indicate that the template
+    // is not a SFINAE template. If there are no mismatches, the caller
+    // continues to check the controlling parameters of the template.
+    // This function also updates the `MemberType` and `ParamIdx` variables
+    // so that they can be used to check the controlling parameters.
     auto IsMismatch = [&](CXXRecordDecl* RD, ArrayRef<TemplateArgument> Args)
     {
+        MRDOCS_SYMBOL_TRACE(RD, context_);
+        MRDOCS_SYMBOL_TRACE(Args, context_);
         if (!RD->hasDefinition())
         {
             return false;
         }
+        // Look for member in the record, such
+        // as the member `::type` in `std::enable_if<B,T>`
         auto MemberLookup = RD->lookup(Member);
+        MRDOCS_SYMBOL_TRACE(MemberLookup, context_);
         QualType CurrentType;
         if(MemberLookup.empty())
         {
             if (!RD->getNumBases())
             {
+                // Didn't find a definition for the specified member and
+                // there can't be a base class that defines the
+                // specified member: no mismatch
                 return false;
             }
             for(auto& Base : RD->bases())
             {
-                auto sfinae_info = getSFINAETemplate(Base.getType(), false);
+                auto sfinae_info = getSFINAETemplateInfo(Base.getType(), false);
                 if(! sfinae_info)
                 {
                     // if the base is an opaque dependent type, we can't determine
@@ -2233,7 +2270,7 @@ isSFINAETemplate(
                     return true;
                 }
 
-                auto sfinae_result = isSFINAETemplate(
+                auto sfinae_result = getSFINAEControlParams(
                     sfinae_info->Template, Member);
                 if (!sfinae_result)
                 {
@@ -2264,15 +2301,26 @@ isSFINAETemplate(
         }
         else
         {
-            // ambiguous lookup
+            // MemberLookup is not empty.
             if (!MemberLookup.isSingleResult())
             {
+                // Ambiguous lookup: If there's more than one result,
+                // we can't determine if the template is a SFINAE template
+                // and return `true` to indicate that the template is not a
+                // SFINAE template.
                 return true;
             }
             if (auto* TND = dyn_cast<TypedefNameDecl>(MemberLookup.front()))
             {
+                // Update the current type to the underlying type of the
+                // typedef declaration.
+                // For instance, if the member is `::type` in the record
+                // `std::enable_if<true,T>`, then the current type is `T`.
+                // The next checks will occur for this underlying type.
                 CurrentType = TND->getUnderlyingType();
-            } else
+                MRDOCS_SYMBOL_TRACE(CurrentType, context_);
+            }
+            else
             {
                 // the specialization has a member with the right name,
                 // but it isn't an alias declaration/typedef declaration...
@@ -2280,56 +2328,93 @@ isSFINAETemplate(
             }
         }
 
+        // If the current type depends on a template parameter, we need to
+        // find the corresponding template argument in the template arguments
+        // of the primary template. If the template argument is not found,
+        // we can't determine if the template is a SFINAE template and return
+        // `true` to indicate a mismatch.
         if(CurrentType->isDependentType())
         {
-            auto FoundIdx = FindParam(Args, TemplateArgument(CurrentType));
-            if (FoundIdx == static_cast<decltype(FoundIdx)>(-1)
-                || FoundIdx >= PrimaryArgs.size())
+            TemplateArgument asTemplateArg(CurrentType);
+            auto FoundIdx = FindParam(Args, asTemplateArg);
+            if (FoundIdx == static_cast<std::size_t>(-1) ||
+                FoundIdx >= PrimaryArgs.size())
             {
                 return true;
             }
+            // Set the controlling parameter index to the index of the
+            // template argument that controls the SFINAE. For instance,
+            // in the specialization `std::enable_if<true,T>::type`,
+            // `type` is `T`, which corresponds to the second template
+            // parameter `T`, so `ParamIdx` is `1` to represent the
+            // second parameter.
             ParamIdx = FoundIdx;
+            // Get this primary template argument as a template
+            // argument of the current type.
             TemplateArgument MappedPrimary = PrimaryArgs[FoundIdx];
-            assert(MappedPrimary.getKind() == TemplateArgument::Type);
+            MRDOCS_SYMBOL_TRACE(MappedPrimary, context_);
+            // The primary argument in SFINAE should be a type
+            MRDOCS_ASSERT(MappedPrimary.getKind() == TemplateArgument::Type);
+            // Update the current type to the type of the primary argument
             CurrentType = MappedPrimary.getAsType();
+            MRDOCS_SYMBOL_TRACE(CurrentType, context_);
         }
 
+        // Update the type of the member that represents the SFINAE result
+        // to the current type if it is not already set.
         if (MemberType.isNull())
         {
             MemberType = CurrentType;
         }
 
-        return ! context_.hasSameType(MemberType, CurrentType);
+        // As a last check, the current type should be the same as the
+        // type of the member that represents the SFINAE result so that
+        // we can extract SFINAE information from the template.
+        return !context_.hasSameType(MemberType, CurrentType);
     };
 
-    if (IsMismatch(CTD->getTemplatedDecl(), PrimaryArgs))
-    {
-        return std::nullopt;
-    }
+    // Check if there's a mismatch between the primary record and the arguments
+    CXXRecordDecl* PrimaryRD = CTD->getTemplatedDecl();
+    MRDOCS_SYMBOL_TRACE(PrimaryRD, context_);
+    MRDOCS_CHECK_OR(!IsMismatch(PrimaryRD, PrimaryArgs), std::nullopt);
 
+    // Check if there's a mismatch between any explicit specialization and the arguments
     for(auto* CTSD : CTD->specializations())
     {
-        if (CTSD->isExplicitSpecialization()
-            && IsMismatch(CTSD, CTSD->getTemplateArgs().asArray()))
+        MRDOCS_SYMBOL_TRACE(CTSD, context_);
+        if (!CTSD->isExplicitSpecialization())
         {
-            return std::nullopt;
+            continue;
         }
+        ArrayRef<TemplateArgument> SpecArgs = CTSD->getTemplateArgs().asArray();
+        MRDOCS_CHECK_OR(!IsMismatch(CTSD, SpecArgs), std::nullopt);
     }
 
+    // Check if there's a mismatch between any partial specialization and the arguments
     SmallVector<ClassTemplatePartialSpecializationDecl*> PartialSpecs;
     CTD->getPartialSpecializations(PartialSpecs);
-
     for(auto* CTPSD : PartialSpecs)
     {
+        MRDOCS_SYMBOL_TRACE(CTPSD, context_);
         auto PartialArgs = CTPSD->getTemplateArgs().asArray();
-        if (IsMismatch(CTPSD, PartialArgs))
-        {
-            return std::nullopt;
-        }
-        for(std::size_t I = 0; I < PartialArgs.size(); ++I)
+        MRDOCS_SYMBOL_TRACE(PartialArgs, context_);
+        MRDOCS_CHECK_OR(!IsMismatch(CTPSD, PartialArgs), std::nullopt);
+    }
+
+    // Find the controlling parameters of the template, that is, the
+    // template parameters that control the SFINAE result. The controlling
+    // parameters are expressions that cannot be converted to
+    // non-type template parameters.
+    llvm::SmallBitVector ControllingParams(PrimaryArgs.size());
+    for(auto* CTPSD : PartialSpecs) {
+        MRDOCS_SYMBOL_TRACE(CTPSD, context_);
+        auto PartialArgs = CTPSD->getTemplateArgs().asArray();
+        MRDOCS_SYMBOL_TRACE(PartialArgs, context_);
+        for(std::size_t i = 0; i < PartialArgs.size(); ++i)
         {
-            TemplateArgument Arg = PartialArgs[I];
-            switch(Arg.getKind())
+            TemplateArgument Arg = PartialArgs[i];
+            MRDOCS_SYMBOL_TRACE(Arg, context_);
+            switch (Arg.getKind())
             {
             case TemplateArgument::Integral:
             case TemplateArgument::Declaration:
@@ -2345,38 +2430,50 @@ isSFINAETemplate(
             default:
                 continue;
             }
-            ControllingParams.set(I);
-            //.getAsExpr()
+            ControllingParams.set(i);
         }
     }
 
-    return std::make_tuple(CTD->getTemplateParameters(), std::move(ControllingParams), ParamIdx);
+    return SFINAEControlParams(CTD->getTemplateParameters(), std::move(ControllingParams), ParamIdx);
 }
 
-std::optional<ASTVisitor::SFINAEInfo>
-ASTVisitor::
-getSFINAETemplate(QualType T, bool const AllowDependentNames)
+std::optional<ASTVisitor::SFINAETemplateInfo>
+ASTVisitor::getSFINAETemplateInfo(QualType T, bool const AllowDependentNames) const
 {
-    assert(!T.isNull());
-    SFINAEInfo SFINAE;
+    MRDOCS_SYMBOL_TRACE(T, context_);
+    MRDOCS_ASSERT(!T.isNull());
+
+    // If the type is an elaborated type, get the named type
     if (auto* ET = T->getAs<ElaboratedType>())
     {
         T = ET->getNamedType();
     }
 
-    if(auto* DNT = T->getAsAdjusted<DependentNameType>();
+    // If the type is a dependent name type and dependent names are allowed,
+    // extract the identifier and the qualifier's type
+    SFINAETemplateInfo SFINAE;
+    if (auto* DNT = T->getAsAdjusted<DependentNameType>();
         DNT && AllowDependentNames)
     {
         SFINAE.Member = DNT->getIdentifier();
+        MRDOCS_SYMBOL_TRACE(SFINAE.Member, context_);
         T = QualType(DNT->getQualifier()->getAsType(), 0);
+        MRDOCS_SYMBOL_TRACE(T, context_);
     }
 
-    if(auto* TST = T->getAsAdjusted<TemplateSpecializationType>())
+    // If the type is a template specialization type, extract the template name
+    // and the template arguments
+    if (auto* TST = T->getAsAdjusted<TemplateSpecializationType>())
     {
+        MRDOCS_SYMBOL_TRACE(TST, context_);
         SFINAE.Template = TST->getTemplateName().getAsTemplateDecl();
+        MRDOCS_SYMBOL_TRACE(SFINAE.Template, context_);
         SFINAE.Arguments = TST->template_arguments();
+        MRDOCS_SYMBOL_TRACE(SFINAE.Arguments, context_);
         return SFINAE;
     }
+
+    // Return nullopt if the type does not match the expected patterns
     return std::nullopt;
 }
 
@@ -2384,30 +2481,36 @@ std::optional<TemplateArgument>
 ASTVisitor::
 tryGetTemplateArgument(
     TemplateParameterList* Parameters,
-    ArrayRef<TemplateArgument> Arguments,
-    unsigned const Index)
+    ArrayRef<TemplateArgument> const Arguments,
+    std::size_t const Index)
 {
-    if (Index == static_cast<unsigned>(-1))
-    {
-        return std::nullopt;
-    }
+    MRDOCS_SYMBOL_TRACE(Parameters, context_);
+    MRDOCS_SYMBOL_TRACE(Arguments, context_);
+    MRDOCS_CHECK_OR(Index != static_cast<unsigned>(-1), std::nullopt);
+
+    // If the index is within the range of the template arguments, return the argument
     if (Index < Arguments.size())
     {
         return Arguments[Index];
     }
-    if(Parameters && Index < Parameters->size())
+
+    MRDOCS_CHECK_OR(Parameters, std::nullopt);
+    MRDOCS_CHECK_OR(Index < Parameters->size(), std::nullopt);
+
+    // Attempt to get the default argument of the template parameter
+    NamedDecl* ND = Parameters->getParam(Index);
+    MRDOCS_SYMBOL_TRACE(ND, context_);
+    if(auto* TTPD = dyn_cast<TemplateTypeParmDecl>(ND);
+        TTPD && TTPD->hasDefaultArgument())
+    {
+        MRDOCS_SYMBOL_TRACE(TTPD, context_);
+        return TTPD->getDefaultArgument().getArgument();
+    }
+    if(auto* NTTPD = dyn_cast<NonTypeTemplateParmDecl>(ND);
+        NTTPD && NTTPD->hasDefaultArgument())
     {
-        NamedDecl* ND = Parameters->getParam(Index);
-        if(auto* TTPD = dyn_cast<TemplateTypeParmDecl>(ND);
-            TTPD && TTPD->hasDefaultArgument())
-        {
-            return TTPD->getDefaultArgument().getArgument();
-        }
-        if(auto* NTTPD = dyn_cast<NonTypeTemplateParmDecl>(ND);
-            NTTPD && NTTPD->hasDefaultArgument())
-        {
-            return NTTPD->getDefaultArgument().getArgument();
-        }
+        MRDOCS_SYMBOL_TRACE(NTTPD, context_);
+        return NTTPD->getDefaultArgument().getArgument();
     }
     return std::nullopt;
 }
diff --git a/src/lib/AST/ASTVisitor.hpp b/src/lib/AST/ASTVisitor.hpp
index 41ac5a40be..18810c99cd 100644
--- a/src/lib/AST/ASTVisitor.hpp
+++ b/src/lib/AST/ASTVisitor.hpp
@@ -148,18 +148,6 @@ class ASTVisitor
      */
     ExtractionMode mode_ = ExtractionMode::Regular;
 
-    struct SFINAEInfo
-    {
-        TemplateDecl* Template = nullptr;
-        const IdentifierInfo* Member = nullptr;
-        ArrayRef<TemplateArgument> Arguments;
-    };
-
-    template <class InfoTy>
-    struct upsertResult {
-        InfoTy& I;
-        bool isNew;
-    };
 public:
     /** Constructor for ASTVisitor.
 
@@ -636,30 +624,152 @@ class ASTVisitor
     std::string
     getSourceCode(SourceRange const& R) const;
 
-    // Determine if a type is a SFINAE type
-    std::optional<std::pair<QualType, std::vector<TemplateArgument>>>
-    isSFINAEType(QualType T);
+    /*  Struct to hold the underlying type result of a SFINAE type.
 
-    // Determine if a type is a SFINAE type
-    std::optional<std::pair<QualType, std::vector<TemplateArgument>>>
-    isSFINAEType(Type const* T)
+        This struct is used to store the underlying type and the template
+        arguments of a type used in a SFINAE context.
+
+        For instance, for the type `std::enable_if_t<std::is_integral_v<T>, T>`,
+        the `Type` would be `T`, and the `Arguments` would be
+        `{std::is_integral_v<T>, T}`.
+     */
+    struct SFINAEInfo
     {
-        return isSFINAEType(QualType(T, 0));
+        // The underlying type of the SFINAE type.
+        QualType Type;
+
+        // The template arguments used in the SFINAE context.
+        std::vector<TemplateArgument> Arguments;
+    };
+
+    /* Get the underlying type result of a SFINAE type
+
+        This function will return the underlying type of a
+        type used in a SFINAE context.
+
+        For instance, it returns the type `T` for the
+        type `std::enable_if_t<std::is_integral_v<T>, T>`.
+
+        @param T The type to check.
+
+        @return `std::nullopt` if the type is not a SFINAE type,
+        and the underlying type with the template arguments
+        otherwise.
+     */
+    std::optional<SFINAEInfo>
+    extractSFINAEInfo(QualType T);
+
+    // @copydoc extractSFINAEInfo(QualType)
+    std::optional<SFINAEInfo>
+    extractSFINAEInfo(Type const* T)
+    {
+        return extractSFINAEInfo(QualType(T, 0));
     }
 
-    std::optional<
-        std::tuple<TemplateParameterList*, llvm::SmallBitVector, unsigned>>
-    isSFINAETemplate(TemplateDecl* TD, IdentifierInfo const* Member);
+    /* Struct to hold SFINAE information.
 
-    static std::optional<SFINAEInfo>
-    getSFINAETemplate(QualType T, bool AllowDependentNames);
+       This struct is used to store information about a template that is
+       involved in a SFINAE context. It contains the template declaration,
+       the member identifier, and the template arguments.
 
-    static
+       For instance, for the type `std::enabled_if_t<std::is_integral_v<T>, T>`,
+       the struct would contain the `Template` declaration for `std::enable_if`,
+       and the `Arguments` `{std::is_integral_v<T>, T}`.
+     */
+    struct SFINAETemplateInfo
+    {
+        /// The template declaration involved in SFINAE
+        TemplateDecl* Template = nullptr;
+
+        /// The identifier of the member being checked.
+        IdentifierInfo const* Member = nullptr;
+
+        /// The template arguments used in the SFINAE context.
+        ArrayRef<TemplateArgument> Arguments;
+    };
+
+    /* Get the template declaration and member identifier
+
+        This function is a helper used by `extractSFINAEInfo` to
+        extract the template declaration and member identifier
+        from a type used in a SFINAE context.
+
+        For instance, for the type `std::enabled_if_t<std::is_integral_v<T>, T>`,
+        the struct would contain the `Template` declaration for `std::enable_if`,
+        and the `Arguments` `{std::is_integral_v<T>, T}`.
+
+        If `AllowDependentNames` is set to `true`, the function will
+        also populate the `Member` field with the member identifier
+        if the type is a dependent name type. For instance,
+        for the type `typename std::enable_if<B,T>::type`, the `Member`
+        field would be `type`, and the other fields would be populated
+        respective to `std::enable_if<B,T>`: `Template` would be `std::enable_if`,
+        and `Arguments` would be `{B,T}`.
+     */
+    std::optional<SFINAETemplateInfo>
+    getSFINAETemplateInfo(QualType T, bool AllowDependentNames) const;
+
+    /* The controlling parameters of a SFINAE template
+
+       This struct is used to store information about the controlling
+       parameters of a template that is involved in a SFINAE context.
+
+       It contains the template parameters, the controlling parameters,
+       and the index of the parameter that represents the result.
+
+       For instance, for the template `template<bool B, typename T> typename
+       std::enable_if<B,T>::type`, the struct would contain the template
+       parameters `{B, T}`, the index of the controlling parameters `{B}`,
+       and the index `1` to represent the second result parameter `T`.
+     */
+    struct SFINAEControlParams
+    {
+        // The template parameters of the template declaration
+        TemplateParameterList* Parameters = nullptr;
+
+        // The controlling parameters of the template declaration
+        llvm::SmallBitVector ControllingParams;
+
+        // The index of the parameter that represents the SFINAE result
+        std::size_t ParamIdx = static_cast<std::size_t>(-1);
+    };
+
+    /* Determine if a template is SFINAE and returns constraints
+
+       This function is used by `isSFINAETemplate` to determine if a
+       template is involved in a SFINAE context.
+
+       If the template is involved in a SFINAE context, the function
+       will return the template parameters, the controlling parameters,
+       and the index of the parameter that controls the SFINAE context.
+
+       If the template is an alias (such as `std::enable_if_t`), the
+       template information of the underlying type
+       (such as `typename enable_if<B,T>::type`) will be extract instead.
+     */
+    std::optional<SFINAEControlParams>
+    getSFINAEControlParams(TemplateDecl* TD, IdentifierInfo const* Member);
+
+    std::optional<SFINAEControlParams>
+    getSFINAEControlParams(SFINAETemplateInfo const& SFINAE) {
+        return getSFINAEControlParams(SFINAE.Template, SFINAE.Member);
+    }
+
+    /* Get the template argument with specified index.
+
+        If the index is a valid index in the template arguments,
+        the function will return the template argument at the
+        specified index.
+
+        If the index is outside the bounds of the
+        arguments, the function will attempt to get the
+        argument from the default template arguments.
+     */
     std::optional<TemplateArgument>
     tryGetTemplateArgument(
         TemplateParameterList* Parameters,
         ArrayRef<TemplateArgument> Arguments,
-        unsigned Index);
+        std::size_t Index);
 
     // =================================================
     // Filters
@@ -806,6 +916,20 @@ class ASTVisitor
     FileInfo*
     findFileInfo(clang::SourceLocation loc);
 
+    /* Result of an upsert operation
+
+        This struct is used to return the result of an
+        upsert operation. The struct contains a reference
+        to the Info object that was created or found, and
+        a boolean flag indicating whether the Info object
+        was newly created or not.
+     */
+    template <class InfoTy>
+    struct upsertResult {
+        InfoTy& I;
+        bool isNew;
+    };
+
     /*  Get or construct an empty Info with a specified id.
 
         If an Info object for the declaration has already
diff --git a/src/lib/AST/ClangHelpers.hpp b/src/lib/AST/ClangHelpers.hpp
index 12a4f040d8..a180545940 100644
--- a/src/lib/AST/ClangHelpers.hpp
+++ b/src/lib/AST/ClangHelpers.hpp
@@ -731,6 +731,26 @@ MRDOCS_DECL
 QualType
 getDeclaratorType(const DeclaratorDecl* DD);
 
+/** Get the NonTypeTemplateParm of an expression
+
+    This function will return the NonTypeTemplateParmDecl
+    corresponding to the expression `E` if it is a
+    NonTypeTemplateParmDecl. If the expression is not
+    a NonTypeTemplateParmDecl, the function will return
+    nullptr.
+
+    For instance, given the expression `x` in the following
+    code snippet:
+
+    @code
+    template<int x>
+    void f() {}
+    @endcode
+
+    the function will return the NonTypeTemplateParmDecl
+    corresponding to `x`, which is the template parameter
+    of the function `f`.
+ */
 MRDOCS_DECL
 NonTypeTemplateParmDecl const*
 getNTTPFromExpr(const Expr* E, unsigned Depth);
@@ -779,11 +799,6 @@ isAllImplicit(Decl const* D);
 #ifdef NDEBUG
 #define MRDOCS_SYMBOL_TRACE(D, C)
 #else
-
-#    define MRDOCS_SYMBOL_TRACE_MERGE_(a, b) a##b
-#    define MRDOCS_SYMBOL_TRACE_LABEL_(a)    MRDOCS_SYMBOL_TRACE_MERGE_(symbol_name_, a)
-#    define MRDOCS_SYMBOL_TRACE_UNIQUE_NAME  MRDOCS_SYMBOL_TRACE_LABEL_(__LINE__)
-
 namespace detail {
     // concept to check if ID->printQualifiedName(
     // std::declval<llvm::raw_svector_ostream&>(),
@@ -801,6 +816,35 @@ namespace detail {
         D.print(OS, PP);
     };
 
+    template <class T>
+    concept HasPrintWithPolicyFirst = requires(T const& D, llvm::raw_svector_ostream& OS, PrintingPolicy PP)
+    {
+        D.print(PP, OS, true);
+    };
+
+    template <class T>
+    concept HasDump = requires(T const& D, llvm::raw_svector_ostream& OS, ASTContext const& C)
+    {
+        D.dump(OS, C);
+    };
+
+    template <class T>
+    concept ConvertibleToUnqualifiedQualType = requires(T const& D)
+    {
+        QualType(&D, 0);
+    };
+
+    template <class T>
+    concept HasGetName = requires(T const& D)
+    {
+        D.getName();
+    };
+
+    template <class T>
+    requires (!std::is_pointer_v<T>)
+    void
+    printTraceName(T const& D, ASTContext const& C, SmallString<256>& symbol_name);
+
     template <class T>
     void
     printTraceName(T const* D, ASTContext const& C, SmallString<256>& symbol_name)
@@ -829,6 +873,38 @@ namespace detail {
         {
             D->print(os, C.getPrintingPolicy());
         }
+        else if constexpr (HasPrintWithPolicyFirst<T>)
+        {
+            D->print(C.getPrintingPolicy(), os, true);
+        }
+        else if constexpr (ConvertibleToUnqualifiedQualType<T>)
+        {
+            QualType const QT(D, 0);
+            QT.print(os, C.getPrintingPolicy());
+        }
+        else if constexpr (HasDump<T>)
+        {
+            D->dump(os, C);
+        }
+        else if constexpr (HasGetName<T>)
+        {
+            os << D->getName();
+        }
+        else if constexpr (std::ranges::range<T>)
+        {
+            bool first = true;
+            os << "{";
+            for (auto it = D->begin(); it != D->end(); ++it)
+            {
+                if (!first)
+                {
+                    os << ", ";
+                }
+                first = false;
+                printTraceName(*it, C, symbol_name);
+            }
+            os << "}";
+        }
     }
 
     template <class T>
@@ -840,6 +916,9 @@ namespace detail {
     }
 } // namespace detail
 
+#    define MRDOCS_SYMBOL_TRACE_MERGE_(a, b) a##b
+#    define MRDOCS_SYMBOL_TRACE_LABEL_(a)    MRDOCS_SYMBOL_TRACE_MERGE_(symbol_name_, a)
+#    define MRDOCS_SYMBOL_TRACE_UNIQUE_NAME  MRDOCS_SYMBOL_TRACE_LABEL_(__LINE__)
 #define MRDOCS_SYMBOL_TRACE(D, C) \
     SmallString<256> MRDOCS_SYMBOL_TRACE_UNIQUE_NAME;         \
     detail::printTraceName(D, C, MRDOCS_SYMBOL_TRACE_UNIQUE_NAME); \
diff --git a/src/lib/AST/TerminalTypeVisitor.hpp b/src/lib/AST/TerminalTypeVisitor.hpp
index 11910eea9b..c3b7b5fe13 100644
--- a/src/lib/AST/TerminalTypeVisitor.hpp
+++ b/src/lib/AST/TerminalTypeVisitor.hpp
@@ -117,12 +117,18 @@ class TerminalTypeVisitor
         This function stores the local qualifiers of the given
         Qualified Type and calls the corresponding `VisitXXXType`
         function for the associated `Type`.
+
+        Example:
+        - Wrapped type: `const int`
+        - Unwrapped type: `int`
      */
     bool
     Visit(QualType const QT)
     {
+        MRDOCS_SYMBOL_TRACE(QT, Visitor_.context_);
         Quals_ |= QT.getLocalFastQualifiers();
         Type const* T = QT.getTypePtrOrNull();
+        MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
         return Visit(T);
     }
 
@@ -284,23 +290,45 @@ class TerminalTypeVisitor
         return static_cast<Derived&>(*this);
     }
 
-    // A type with parentheses, e.g., `(int)`.
+    /** Visit a type with parentheses, e.g., `(int)`.
+
+        This function unwraps the inner type from the parentheses.
+
+        Example:
+        - Wrapped type: `(int)`
+        - Unwrapped type: `int`
+     */
     bool
-    VisitParenType(
-        const ParenType* T)
+    VisitParenType(const ParenType* T)
     {
         QualType I = T->getInnerType();
         return Visit(I);
     }
 
+    /** Visit a macro qualified type.
+
+        This function unwraps the underlying type from the macro qualifier.
+
+        Example:
+        - Wrapped type: `MACRO_QUALIFIED(int)`
+        - Unwrapped type: `int`
+     */
     bool
     VisitMacroQualified(
-        const MacroQualifiedType* T)
+        MacroQualifiedType const* T)
     {
         QualType UT = T->getUnderlyingType();
         return Visit(UT);
     }
 
+    /** Visit an attributed type.
+
+        This function unwraps the modified type from the attribute.
+
+        Example:
+        - Wrapped type: `[[attribute]] int`
+        - Unwrapped type: `int`
+     */
     bool
     VisitAttributedType(
         const AttributedType* T)
@@ -309,22 +337,44 @@ class TerminalTypeVisitor
         return Visit(MT);
     }
 
+    /** Visit an adjusted type.
+
+        This function unwraps the original type from the adjusted type.
+
+        Example:
+        - Wrapped type: adjusted/decayed `int*`
+        - Unwrapped type: original `int[4]`
+     */
     bool
-    VisitAdjustedType(
-        const AdjustedType* T)
+    VisitAdjustedType(AdjustedType const* T)
     {
         QualType OT = T->getOriginalType();
         return Visit(OT);
     }
 
+    /** Visit a using type.
+
+        This function unwraps the underlying type from the using type.
+
+        Example:
+        - Wrapped type: `using TypeAlias = int`
+        - Unwrapped type: `int`
+     */
     bool
-    VisitUsingType(
-        const UsingType* T)
+    VisitUsingType(UsingType const* T)
     {
         QualType UT = T->getUnderlyingType();
         return Visit(UT);
     }
 
+    /** Visit a substituted template type parameter type.
+
+        This function unwraps the replacement type from the substituted template type parameter.
+
+        Example:
+        - Wrapped type: `T`
+        - Unwrapped type: `int` (if `T` is substituted with `int`)
+     */
     bool
     VisitSubstTemplateTypeParmType(
         const SubstTemplateTypeParmType* T)
@@ -335,17 +385,38 @@ class TerminalTypeVisitor
 
     // ----------------------------------------------------------------
 
-    // A type that was referred to using an elaborated type keyword,
-    // e.g., `struct S`, or via a qualified name, e.g., `N::M::type`.
+
+
+    /** Visit an elaborated type.
+
+        This function unwraps the named type from the elaborated type:
+        a type that was referred to using an elaborated type keyword,
+        e.g., `struct S`, or via a qualified name, e.g., `N::M::type`.
+
+        Example:
+        - Wrapped type: `struct S`
+        - Unwrapped type: `S`
+     */
     bool
     VisitElaboratedType(
         const ElaboratedType* T)
     {
+        MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
         NNS_ = T->getQualifier();
+        MRDOCS_SYMBOL_TRACE(NNS_, Visitor_.context_);
         QualType NT = T->getNamedType();
+        MRDOCS_SYMBOL_TRACE(NT, Visitor_.context_);
         return Visit(NT);
     }
 
+    /** Visit a pack expansion type.
+
+        This function unwraps the pattern type from the pack expansion.
+
+        Example:
+        - Wrapped type: `int...`
+        - Unwrapped type: `int`
+     */
     bool
     VisitPackExpansionType(
         const PackExpansionType* T)
@@ -357,6 +428,14 @@ class TerminalTypeVisitor
 
     // ----------------------------------------------------------------
 
+    /** Visit a pointer type.
+
+        This function unwraps the pointee type from the pointer type.
+
+        Example:
+        - Wrapped type: `int*`
+        - Unwrapped type: `int`
+     */
     bool
     VisitPointerType(
         const PointerType* T)
@@ -366,6 +445,14 @@ class TerminalTypeVisitor
         return Visit(PT);
     }
 
+    /** Visit an lvalue reference type.
+
+        This function unwraps the pointee type from the lvalue reference type.
+
+        Example:
+        - Wrapped type: `int&`
+        - Unwrapped type: `int`
+     */
     bool
     VisitLValueReferenceType(
         const LValueReferenceType* T)
@@ -376,6 +463,14 @@ class TerminalTypeVisitor
         return Visit(PT);
     }
 
+    /** Visit an rvalue reference type.
+
+        This function unwraps the pointee type from the rvalue reference type.
+
+        Example:
+        - Wrapped type: `int&&`
+        - Unwrapped type: `int`
+     */
     bool
     VisitRValueReferenceType(
         const RValueReferenceType* T)
@@ -386,6 +481,14 @@ class TerminalTypeVisitor
         return Visit(PT);
     }
 
+    /** Visit a member pointer type.
+
+        This function unwraps the pointee type from the member pointer type.
+
+        Example:
+        - Wrapped type: `int Class::*`
+        - Unwrapped type: `int`
+     */
     bool
     VisitMemberPointerType(
         const MemberPointerType* T)
@@ -404,6 +507,14 @@ class TerminalTypeVisitor
         return Visit(RT);
     }
 
+    /** Visit an array type.
+
+        This function unwraps the element type from the array type.
+
+        Example:
+        - Wrapped type: `int[10]`
+        - Unwrapped type: `int`
+     */
     bool
     VisitArrayType(
         const ArrayType* T)
@@ -457,7 +568,7 @@ class TerminalTypeVisitor
     VisitDependentNameType(
         const DependentNameType* T)
     {
-        if (auto SFINAE = getASTVisitor().isSFINAEType(T); SFINAE.has_value())
+        if (auto SFINAE = getASTVisitor().extractSFINAEInfo(T))
         {
             return getDerived().Visit(SFINAE->first);
         }
@@ -475,6 +586,7 @@ class TerminalTypeVisitor
     VisitDependentTemplateSpecializationType(
         const DependentTemplateSpecializationType* T)
     {
+        MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
         if (auto const* NNS = T->getQualifier())
         {
             NNS_ = NNS;
@@ -489,7 +601,8 @@ class TerminalTypeVisitor
     VisitTemplateSpecializationType(
         TemplateSpecializationType const* T)
     {
-        if (auto SFINAE = getASTVisitor().isSFINAEType(T); SFINAE.has_value())
+        MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
+        if (auto SFINAE = getASTVisitor().extractSFINAEInfo(T))
         {
             return getDerived().Visit(SFINAE->first);
         }
@@ -574,9 +687,11 @@ class TerminalTypeVisitor
     VisitTemplateTypeParmType(
         const TemplateTypeParmType* T)
     {
+        MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
         const IdentifierInfo* II = nullptr;
         if (TemplateTypeParmDecl const* D = T->getDecl())
         {
+            MRDOCS_SYMBOL_TRACE(D, Visitor_.context_);
             if(D->isImplicit())
             {
                 // special case for implicit template parameters
diff --git a/src/lib/Lib/ConfigOptions.json b/src/lib/Lib/ConfigOptions.json
index 4842722b77..dee5e87e5b 100644
--- a/src/lib/Lib/ConfigOptions.json
+++ b/src/lib/Lib/ConfigOptions.json
@@ -167,7 +167,7 @@
       {
         "name": "sfinae",
         "brief": "Detect and reduce SFINAE expressions",
-        "details": "When set to true, MrDocs detects SFINAE expressions in the source code and extracts them as part of the documentation. Expressions such as `std::enable_if<...>` are detected, removed, and documented as a requirement.",
+        "details": "When set to true, MrDocs detects SFINAE expressions in the source code and extracts them as part of the documentation. Expressions such as `std::enable_if<...>` are detected, removed, and documented as a requirement. MrDocs uses an algorithm that extracts SFINAE infomation from types by identifying inspecting the primary template and specializations to detect the result type and the controlling expressions in a specialization.",
         "type": "bool",
         "default": true
       },

From e4a2a00f479e93b51f22ab8b83723627610e8082 Mon Sep 17 00:00:00 2001
From: alandefreitas <alandefreitas@gmail.com>
Date: Tue, 14 Jan 2025 16:52:42 -0300
Subject: [PATCH 4/6] SFINAE substitutions reset NestedNameSpecifier

#fix

fix #774
---
 src/lib/AST/TerminalTypeVisitor.hpp        | 8 +++++---
 test-files/golden-tests/core/libcxx.adoc   | 2 +-
 test-files/golden-tests/core/libcxx.html   | 2 +-
 test-files/golden-tests/core/libcxx.xml    | 2 +-
 test-files/golden-tests/snippets/sqrt.adoc | 2 +-
 test-files/golden-tests/snippets/sqrt.html | 2 +-
 test-files/golden-tests/snippets/sqrt.xml  | 2 +-
 7 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/lib/AST/TerminalTypeVisitor.hpp b/src/lib/AST/TerminalTypeVisitor.hpp
index c3b7b5fe13..d131ef05d6 100644
--- a/src/lib/AST/TerminalTypeVisitor.hpp
+++ b/src/lib/AST/TerminalTypeVisitor.hpp
@@ -85,7 +85,7 @@ class TerminalTypeVisitor
     bool IsPack_ = false;
 
     // The optional NestedNameSpecifier.
-    const NestedNameSpecifier* NNS_;
+    const NestedNameSpecifier* NNS_ = nullptr;
 
 public:
     /** Constructor for TerminalTypeVisitor.
@@ -570,7 +570,8 @@ class TerminalTypeVisitor
     {
         if (auto SFINAE = getASTVisitor().extractSFINAEInfo(T))
         {
-            return getDerived().Visit(SFINAE->first);
+            NNS_ = nullptr;
+            return getDerived().Visit(SFINAE->Type);
         }
 
         if (auto const* NNS = T->getQualifier())
@@ -604,7 +605,8 @@ class TerminalTypeVisitor
         MRDOCS_SYMBOL_TRACE(T, Visitor_.context_);
         if (auto SFINAE = getASTVisitor().extractSFINAEInfo(T))
         {
-            return getDerived().Visit(SFINAE->first);
+            NNS_ = nullptr;
+            return getDerived().Visit(SFINAE->Type);
         }
 
         // In most cases, a template name is simply a reference
diff --git a/test-files/golden-tests/core/libcxx.adoc b/test-files/golden-tests/core/libcxx.adoc
index 15b1d74179..29e6e9d4d2 100644
--- a/test-files/golden-tests/core/libcxx.adoc
+++ b/test-files/golden-tests/core/libcxx.adoc
@@ -34,7 +34,7 @@ Declared in `&lt;libcxx&period;cpp&gt;`
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
 template&lt;typename T&gt;
-<<std,std>>::T
+T
 sqrt(T value);
 ----
 
diff --git a/test-files/golden-tests/core/libcxx.html b/test-files/golden-tests/core/libcxx.html
index c25e995c44..c9e8446a3d 100644
--- a/test-files/golden-tests/core/libcxx.html
+++ b/test-files/golden-tests/core/libcxx.html
@@ -40,7 +40,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">
 template&lt;typename T&gt;
-<a href="#std">std</a>::T
+T
 sqrt(T value);
 </code>
 </pre>
diff --git a/test-files/golden-tests/core/libcxx.xml b/test-files/golden-tests/core/libcxx.xml
index 21ccb072d4..fd73826747 100644
--- a/test-files/golden-tests/core/libcxx.xml
+++ b/test-files/golden-tests/core/libcxx.xml
@@ -7,7 +7,7 @@
     <function name="sqrt" id="ulFDUE1svTCX8fV/h8EIp4NNbWs=">
       <file path="libcxx.cpp" line="149"/>
       <return>
-        <type name="std::T"/>
+        <type name="T"/>
       </return>
       <param name="value">
         <type name="T"/>
diff --git a/test-files/golden-tests/snippets/sqrt.adoc b/test-files/golden-tests/snippets/sqrt.adoc
index 4646f46c6b..f357e6a0df 100644
--- a/test-files/golden-tests/snippets/sqrt.adoc
+++ b/test-files/golden-tests/snippets/sqrt.adoc
@@ -34,7 +34,7 @@ Declared in `&lt;sqrt&period;cpp&gt;`
 [source,cpp,subs="verbatim,replacements,macros,-callouts"]
 ----
 template&lt;typename T&gt;
-<<std,std>>::T
+T
 sqrt(T value);
 ----
 
diff --git a/test-files/golden-tests/snippets/sqrt.html b/test-files/golden-tests/snippets/sqrt.html
index 6599acb715..e723b10a4d 100644
--- a/test-files/golden-tests/snippets/sqrt.html
+++ b/test-files/golden-tests/snippets/sqrt.html
@@ -40,7 +40,7 @@ <h3>Synopsis</h3>
 <pre>
 <code class="source-code cpp">
 template&lt;typename T&gt;
-<a href="#std">std</a>::T
+T
 sqrt(T value);
 </code>
 </pre>
diff --git a/test-files/golden-tests/snippets/sqrt.xml b/test-files/golden-tests/snippets/sqrt.xml
index 02350965ba..6427b0ad35 100644
--- a/test-files/golden-tests/snippets/sqrt.xml
+++ b/test-files/golden-tests/snippets/sqrt.xml
@@ -7,7 +7,7 @@
     <function name="sqrt" id="ulFDUE1svTCX8fV/h8EIp4NNbWs=">
       <file path="sqrt.cpp" line="15" class="def"/>
       <return>
-        <type name="std::T"/>
+        <type name="T"/>
       </return>
       <param name="value">
         <type name="T"/>

From 2fb4134589a95856673f29e695839b4be3b5ae6a Mon Sep 17 00:00:00 2001
From: alandefreitas <alandefreitas@gmail.com>
Date: Tue, 14 Jan 2025 17:16:33 -0300
Subject: [PATCH 5/6] XMLWriter excludes dependencies

#fix
---
 src/lib/Gen/xml/XMLWriter.cpp                 |  7 ++++
 .../filters/symbol-name/blacklist_0.xml       | 11 ------
 .../symbol-name/excluded-namespace-alias.xml  |  4 --
 .../filters/symbol-name/extraction-mode.xml   | 37 -------------------
 4 files changed, 7 insertions(+), 52 deletions(-)

diff --git a/src/lib/Gen/xml/XMLWriter.cpp b/src/lib/Gen/xml/XMLWriter.cpp
index 5b99a34ea3..fe0671228d 100644
--- a/src/lib/Gen/xml/XMLWriter.cpp
+++ b/src/lib/Gen/xml/XMLWriter.cpp
@@ -195,6 +195,13 @@ XMLWriter::
 operator()(
     T const& I)
 {
+    Info const& base = I;
+    if (base.Extraction == ExtractionMode::Dependency)
+    {
+        return;
+    }
+
+
     #define INFO(Type) if constexpr(T::is##Type()) write##Type(I);
     #include <mrdocs/Metadata/InfoNodesPascal.inc>
 }
diff --git a/test-files/golden-tests/filters/symbol-name/blacklist_0.xml b/test-files/golden-tests/filters/symbol-name/blacklist_0.xml
index 956874f3e2..481d668259 100644
--- a/test-files/golden-tests/filters/symbol-name/blacklist_0.xml
+++ b/test-files/golden-tests/filters/symbol-name/blacklist_0.xml
@@ -7,17 +7,6 @@
       <file path="blacklist_0.cpp" line="3"/>
       <file path="blacklist_0.cpp" line="16"/>
     </function>
-    <namespace name="N1_BL" id="jVE2p1i0UYk89pn+WDz4eo5TtqY=">
-      <function name="f1" id="GZOWK/jcE53ZZmWVzFx8XNJbbcw=">
-        <file path="blacklist_0.cpp" line="17"/>
-      </function>
-    </namespace>
-    <struct name="S0_BL" id="DQybmH4GmrFs/AMwQ8xUtIXTtFw=">
-      <file path="blacklist_0.cpp" line="10" class="def"/>
-      <function name="f2" id="MY6mDcv064Ns4eMtVO7GTdXsGMk=">
-        <file path="blacklist_0.cpp" line="18" class="def"/>
-      </function>
-    </struct>
   </namespace>
   <namespace name="N3" id="N8VuRKoz/jzHCbelCVCZNKALQAQ=">
   </namespace>
diff --git a/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.xml b/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.xml
index e88559cfe9..b78ad6eec2 100644
--- a/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.xml
+++ b/test-files/golden-tests/filters/symbol-name/excluded-namespace-alias.xml
@@ -3,10 +3,6 @@
        xsi:noNamespaceSchemaLocation="https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc">
 <namespace id="//////////////////////////8=">
   <namespace name="B" id="kPgq2AM8TvyGDGm5jEWfqYlOPmY=">
-    <namespace name="S" id="Rj2Fd5N7JujyJxCEKO4hXgEbuZE=">
-      <namespace name="E" id="3Bv76oUtQq1hnBVVkwioGwKa0oU=">
-      </namespace>
-    </namespace>
     <namespace name="U" id="X48ZrJbrwHITObLn6vxlcgApA20=">
       <namespace-alias name="E" id="TDj0Rc30uD7P5e+F1gsHzHoaV2U=">
         <file path="excluded-namespace-alias.cpp" line="7"/>
diff --git a/test-files/golden-tests/filters/symbol-name/extraction-mode.xml b/test-files/golden-tests/filters/symbol-name/extraction-mode.xml
index a85814e5f2..9ee08a19ad 100644
--- a/test-files/golden-tests/filters/symbol-name/extraction-mode.xml
+++ b/test-files/golden-tests/filters/symbol-name/extraction-mode.xml
@@ -107,18 +107,6 @@
         </para>
       </doc>
     </function>
-    <struct name="dependency" id="1L0CXReBnwnJJ+QMfbufLsSVX8Q=">
-      <file path="extraction-mode.cpp" line="89" class="def"/>
-      <doc>
-        <para>
-          <text>An excluded symbol used as a dependency by a regular symbol</text>
-        </para>
-        <para>
-          <text>A symbol excluded by filters but is used as a dependency The symbol should be extracted as a dependency but its</text>
-          <text> members should not be traversed.</text>
-        </para>
-      </doc>
-    </struct>
     <function name="get_dependency" id="JsA4nL3r830aRrxkYOJehKibEWE=">
       <file path="extraction-mode.cpp" line="102" class="def"/>
       <return>
@@ -200,21 +188,6 @@
         </para>
       </doc>
     </function>
-    <struct name="dependency" id="CyWO4Tsh/ybq2vl/ylZdyGSc20U=">
-      <file path="extraction-mode.cpp" line="174" class="def"/>
-      <doc>
-        <para>
-          <text>A dependency symbol in a see-below namespace</text>
-        </para>
-        <para>
-          <text>The symbol should be extracted as a dependency because the exclude filter has precedence over the see-below filter.</text>
-          <text> Only included symbols can be promoted to see-below.</text>
-        </para>
-        <para>
-          <text>This will not have a page and functions using this symbol should explain the dependency.</text>
-        </para>
-      </doc>
-    </struct>
     <function name="get_dependency" id="a9NW/0+lwniKyNoc79ktu9ydz9Q=">
       <file path="extraction-mode.cpp" line="184" class="def"/>
       <return>
@@ -265,8 +238,6 @@
     </doc>
     <aliased name="implementation_defined_ns" id="ZYn+worzOdzCMW6yaZC9jAkpVTk="/>
   </namespace-alias>
-  <namespace name="dependency_ns" id="FVHkx2YC1v9lxjwdG5D+M2e5SIA=">
-  </namespace>
   <namespace-alias name="dependency_ns_alias" id="iz2edsTj1BrHatwuxuBXSOfqpDE=">
     <file path="extraction-mode.cpp" line="233"/>
     <doc>
@@ -375,14 +346,6 @@
       </para>
     </doc>
   </function>
-  <struct name="dependency" id="t1gs2ps85mDDF3gcK68GCS5x23g=">
-    <file path="extraction-mode.cpp" line="307" class="def"/>
-    <doc>
-      <para>
-        <text>A dependency symbol in the global namespace</text>
-      </para>
-    </doc>
-  </struct>
   <function name="get_dependency" id="TDPbPaUgAt15wH9Aq054dH6qByE=">
     <file path="extraction-mode.cpp" line="313" class="def"/>
     <return>

From a9d1b40b88bbe13d4888d1d0b295441d17f4944e Mon Sep 17 00:00:00 2001
From: alandefreitas <alandefreitas@gmail.com>
Date: Tue, 14 Jan 2025 17:17:57 -0300
Subject: [PATCH 6/6] test SFINAE variants

#test
---
 test-files/golden-tests/metadata/sfinae.adoc | 392 ++++++++++++++++++
 test-files/golden-tests/metadata/sfinae.cpp  |  73 ++++
 test-files/golden-tests/metadata/sfinae.html | 411 +++++++++++++++++++
 test-files/golden-tests/metadata/sfinae.xml  | 226 ++++++++++
 4 files changed, 1102 insertions(+)
 create mode 100644 test-files/golden-tests/metadata/sfinae.adoc
 create mode 100644 test-files/golden-tests/metadata/sfinae.cpp
 create mode 100644 test-files/golden-tests/metadata/sfinae.html
 create mode 100644 test-files/golden-tests/metadata/sfinae.xml

diff --git a/test-files/golden-tests/metadata/sfinae.adoc b/test-files/golden-tests/metadata/sfinae.adoc
new file mode 100644
index 0000000000..6514206618
--- /dev/null
+++ b/test-files/golden-tests/metadata/sfinae.adoc
@@ -0,0 +1,392 @@
+= Reference
+:mrdocs:
+
+[#index]
+== Global namespace
+
+
+=== Namespaces
+
+[cols=1]
+|===
+| Name 
+
+| <<B,`B`>> 
+|===
+=== Types
+
+[cols=2]
+|===
+| Name | Description 
+
+| <<A-09,`A`>> 
+| The partial specialization of A is enabled via a template parameter
+
+
+
+| <<A-02,`A&lt;T, void&gt;`>> 
+| Specialization for floating point types
+
+
+
+|===
+=== Functions
+
+[cols=2]
+|===
+| Name | Description 
+
+| <<f1,`f1`>> 
+| Enabled via return type
+
+
+
+| <<f10,`f10`>> 
+| Enabled via type template parameter
+
+
+
+| <<f2,`f2`>> 
+| Enabling a specified return type
+
+
+
+| <<f3,`f3`>> 
+| Enabling a specified return type in another namespace
+
+
+
+| <<f4,`f4`>> 
+| Enabled via return type with std&colon;&colon;enable&lowbar;if
+
+
+
+| <<f5,`f5`>> 
+| Enabled via a non&hyphen;type template parameter with helper
+
+
+
+| <<f6,`f6`>> 
+| Enabled via a non&hyphen;type template parameter without helper
+
+
+
+| <<f7,`f7`>> 
+| Enabled via a non&hyphen;type template parameter using int instead of bool
+
+
+
+| <<f8,`f8`>> 
+| Enabled via parameter without helper
+
+
+
+| <<f9,`f9`>> 
+| Enabled via parameter with helper
+
+
+
+|===
+
+[#B]
+== B
+
+
+=== Types
+
+[cols=1]
+|===
+| Name 
+
+| <<B-C,`C`>> 
+|===
+
+[#B-C]
+== <<B,B>>::C
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+struct C;
+----
+
+
+
+
+[#A-09]
+== A
+
+
+The partial specialization of A is enabled via a template parameter
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;
+    class T,
+    class Enable = void&gt;
+class A;
+----
+
+
+
+
+[#A-02]
+== A&lt;T, void&gt;
+
+
+Specialization for floating point types
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class T&gt;
+class <<A-09,A>>&lt;T, void&gt;;
+----
+
+
+
+
+[#f1]
+== f1
+
+
+Enabled via return type
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class T&gt;
+T
+f1(T value);
+----
+
+[#f10]
+== f10
+
+
+Enabled via type template parameter
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;
+    class T,
+    typename = void&gt;
+void
+f10(T* t);
+----
+
+=== Description
+
+
+This pattern should not be used because the function signature is unmodified and therefore only supports one overload&period;
+
+It&apos;s a common mistake is to declare two function templates that differ only in their default template arguments&period;
+
+This does not work because the declarations are treated as redeclarations of the same function template (default template arguments are not accounted for in function template equivalence)&period;
+
+
+
+[#f2]
+== f2
+
+
+Enabling a specified return type
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class T&gt;
+int
+f2(T value);
+----
+
+[#f3]
+== f3
+
+
+Enabling a specified return type in another namespace
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class T&gt;
+<<B,B>>::<<B-C,C>>
+f3(T value);
+----
+
+[#f4]
+== f4
+
+
+Enabled via return type with std&colon;&colon;enable&lowbar;if
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class T&gt;
+T
+f4(T value);
+----
+
+[#f5]
+== f5
+
+
+Enabled via a non&hyphen;type template parameter with helper
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;
+    class T,
+    bool = true&gt;
+T
+f5(T value);
+----
+
+[#f6]
+== f6
+
+
+Enabled via a non&hyphen;type template parameter without helper
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;
+    class T,
+    bool = true&gt;
+T
+f6(T value);
+----
+
+[#f7]
+== f7
+
+
+Enabled via a non&hyphen;type template parameter using int instead of bool
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;
+    class T,
+    int = 0&gt;
+void
+f7(T value);
+----
+
+[#f8]
+== f8
+
+
+Enabled via parameter without helper
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class T&gt;
+T
+f8(
+    T value,
+    void* = 0);
+----
+
+[#f9]
+== f9
+
+
+Enabled via parameter with helper
+
+
+
+=== Synopsis
+
+
+Declared in `&lt;sfinae&period;cpp&gt;`
+
+[source,cpp,subs="verbatim,replacements,macros,-callouts"]
+----
+template&lt;class T&gt;
+T
+f9(
+    T value,
+    void* = 0);
+----
+
+
+
+[.small]#Created with https://www.mrdocs.com[MrDocs]#
diff --git a/test-files/golden-tests/metadata/sfinae.cpp b/test-files/golden-tests/metadata/sfinae.cpp
new file mode 100644
index 0000000000..a7c4ef1795
--- /dev/null
+++ b/test-files/golden-tests/metadata/sfinae.cpp
@@ -0,0 +1,73 @@
+#include <type_traits>
+#include <stdexcept>
+
+/// Enabled via return type
+template <class T>
+std::enable_if_t<std::is_integral_v<T>, T>
+f1(T value);
+
+/// Enabling a specified return type
+template <class T>
+std::enable_if_t<std::is_integral_v<T>, int>
+f2(T value);
+
+namespace B {
+    struct C {};
+}
+
+/// Enabling a specified return type in another namespace
+template <class T>
+std::enable_if_t<std::is_integral_v<T>, B::C>
+f3(T value);
+
+/// Enabled via return type with std::enable_if
+template <class T>
+typename std::enable_if<std::is_integral_v<T>, T>::type
+f4(T value);
+
+/// Enabled via a non-type template parameter with helper
+template <class T, std::enable_if_t<std::is_integral_v<T>, bool> = true>
+T
+f5(T value);
+
+/// Enabled via a non-type template parameter without helper
+template<class T, typename std::enable_if<std::is_integral_v<T>, bool>::type = true>
+T
+f6(T value);
+
+/// Enabled via a non-type template parameter using int instead of bool
+template<class T, std::enable_if_t<T::value1, int> = 0>
+void f7(T value);
+
+/// Enabled via parameter without helper
+template <class T>
+T
+f8(T value, typename std::enable_if<std::is_integral_v<T>>::type* = 0);
+
+/// Enabled via parameter with helper
+template <class T>
+T
+f9(T value, std::enable_if_t<std::is_integral_v<T>>* = 0);
+
+/// Enabled via type template parameter
+///
+/// This pattern should not be used because the function signature
+/// is unmodified and therefore only supports one overload.
+///
+/// It's a common mistake is to declare two function templates
+/// that differ only in their default template arguments.
+///
+/// This does not work because the declarations are treated as
+/// redeclarations of the same function template (default template
+/// arguments are not accounted for in function template equivalence).
+///
+template<class T, typename = std::enable_if_t<std::is_integral_v<T>>>
+void f10(T* t);
+
+/// The partial specialization of A is enabled via a template parameter
+template<class T, class Enable = void>
+class A {};
+
+/// Specialization for floating point types
+template<class T>
+class A<T, std::enable_if_t<std::is_integral_v<T>>> {};
diff --git a/test-files/golden-tests/metadata/sfinae.html b/test-files/golden-tests/metadata/sfinae.html
new file mode 100644
index 0000000000..1d9c9d4e52
--- /dev/null
+++ b/test-files/golden-tests/metadata/sfinae.html
@@ -0,0 +1,411 @@
+<html lang="en">
+<head>
+<title>Reference</title>
+</head>
+<body>
+<div>
+<h1>Reference</h1>
+<div>
+<div>
+<h2 id="index">Global namespace</h2>
+</div>
+<h2>Namespaces</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#B"><code>B</code></a> </td></tr>
+</tbody>
+</table>
+<h2>Types</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th><th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#A-09"><code>A</code></a> </td><td><p><span>The partial specialization of A is enabled via a template parameter</span></p>
+
+</td></tr><tr>
+<td><a href="#A-02"><code>A&lt;T, void&gt;</code></a> </td><td><p><span>Specialization for floating point types</span></p>
+
+</td></tr>
+</tbody>
+</table>
+<h2>Functions</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th><th>Description</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#f1"><code>f1</code></a> </td><td><p><span>Enabled via return type</span></p>
+
+</td></tr><tr>
+<td><a href="#f10"><code>f10</code></a> </td><td><p><span>Enabled via type template parameter</span></p>
+
+</td></tr><tr>
+<td><a href="#f2"><code>f2</code></a> </td><td><p><span>Enabling a specified return type</span></p>
+
+</td></tr><tr>
+<td><a href="#f3"><code>f3</code></a> </td><td><p><span>Enabling a specified return type in another namespace</span></p>
+
+</td></tr><tr>
+<td><a href="#f4"><code>f4</code></a> </td><td><p><span>Enabled via return type with std::enable_if</span></p>
+
+</td></tr><tr>
+<td><a href="#f5"><code>f5</code></a> </td><td><p><span>Enabled via a non-type template parameter with helper</span></p>
+
+</td></tr><tr>
+<td><a href="#f6"><code>f6</code></a> </td><td><p><span>Enabled via a non-type template parameter without helper</span></p>
+
+</td></tr><tr>
+<td><a href="#f7"><code>f7</code></a> </td><td><p><span>Enabled via a non-type template parameter using int instead of bool</span></p>
+
+</td></tr><tr>
+<td><a href="#f8"><code>f8</code></a> </td><td><p><span>Enabled via parameter without helper</span></p>
+
+</td></tr><tr>
+<td><a href="#f9"><code>f9</code></a> </td><td><p><span>Enabled via parameter with helper</span></p>
+
+</td></tr>
+</tbody>
+</table>
+</div>
+<div>
+<div>
+<h2 id="B">B</h2>
+</div>
+<h2>Types</h2>
+<table style="table-layout: fixed; width: 100%;">
+<thead>
+<tr>
+<th>Name</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><a href="#B-C"><code>C</code></a> </td></tr>
+</tbody>
+</table>
+</div>
+<div>
+<div>
+<h2 id="B-C"><a href="#B">B</a>::C</h2>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+struct C;
+</code>
+</pre>
+</div>
+
+
+</div>
+<div>
+<div>
+<h2 id="A-09">A</h2>
+<div>
+<p><span>The partial specialization of A is enabled via a template parameter</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;
+    class T,
+    class Enable = void&gt;
+class A;
+</code>
+</pre>
+</div>
+
+
+</div>
+<div>
+<div>
+<h2 id="A-02">A&lt;T, void&gt;</h2>
+<div>
+<p><span>Specialization for floating point types</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;class T&gt;
+class <a href="#A-09">A</a>&lt;T, void&gt;;
+</code>
+</pre>
+</div>
+
+
+</div>
+<div>
+<div>
+<h2 id="f1">f1</h2>
+<div>
+<p><span>Enabled via return type</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;class T&gt;
+T
+f1(T value);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f10">f10</h2>
+<div>
+<p><span>Enabled via type template parameter</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;
+    class T,
+    typename = void&gt;
+void
+f10(T* t);
+</code>
+</pre>
+</div>
+<div>
+<h3>Description</h3>
+<p><span>This pattern should not be used because the function signature is unmodified and therefore only supports one overload.</span></p>
+<p><span>It&#x27;s a common mistake is to declare two function templates that differ only in their default template arguments.</span></p>
+<p><span>This does not work because the declarations are treated as redeclarations of the same function template (default template</span><span> arguments are not accounted for in function template equivalence).</span></p>
+
+
+</div>
+</div>
+<div>
+<div>
+<h2 id="f2">f2</h2>
+<div>
+<p><span>Enabling a specified return type</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;class T&gt;
+int
+f2(T value);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f3">f3</h2>
+<div>
+<p><span>Enabling a specified return type in another namespace</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;class T&gt;
+<a href="#B">B</a>::<a href="#B-C">C</a>
+f3(T value);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f4">f4</h2>
+<div>
+<p><span>Enabled via return type with std::enable_if</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;class T&gt;
+T
+f4(T value);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f5">f5</h2>
+<div>
+<p><span>Enabled via a non-type template parameter with helper</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;
+    class T,
+    bool = true&gt;
+T
+f5(T value);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f6">f6</h2>
+<div>
+<p><span>Enabled via a non-type template parameter without helper</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;
+    class T,
+    bool = true&gt;
+T
+f6(T value);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f7">f7</h2>
+<div>
+<p><span>Enabled via a non-type template parameter using int instead of bool</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;
+    class T,
+    int = 0&gt;
+void
+f7(T value);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f8">f8</h2>
+<div>
+<p><span>Enabled via parameter without helper</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;class T&gt;
+T
+f8(
+    T value,
+    void* = 0);
+</code>
+</pre>
+</div>
+</div>
+<div>
+<div>
+<h2 id="f9">f9</h2>
+<div>
+<p><span>Enabled via parameter with helper</span></p>
+
+
+</div>
+</div>
+<div>
+<h3>Synopsis</h3>
+<div>
+Declared in <code>&lt;sfinae.cpp&gt;</code></div>
+<pre>
+<code class="source-code cpp">
+template&lt;class T&gt;
+T
+f9(
+    T value,
+    void* = 0);
+</code>
+</pre>
+</div>
+</div>
+
+</div>
+<div>
+<h4>Created with <a href="https://www.mrdocs.com">MrDocs</a></h4>
+</div>
+</body>
+</html>
\ No newline at end of file
diff --git a/test-files/golden-tests/metadata/sfinae.xml b/test-files/golden-tests/metadata/sfinae.xml
new file mode 100644
index 0000000000..6ade18dfed
--- /dev/null
+++ b/test-files/golden-tests/metadata/sfinae.xml
@@ -0,0 +1,226 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<mrdocs xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xsi:noNamespaceSchemaLocation="https://github.com/cppalliance/mrdocs/raw/develop/mrdocs.rnc">
+<namespace id="//////////////////////////8=">
+  <template>
+    <tparam name="T" class="type"/>
+    <function name="f1" id="Bs19YS1cqZhrsbv149xgnjRFUAk=">
+      <file path="sfinae.cpp" line="5"/>
+      <return>
+        <type name="T"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via return type</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <function name="f2" id="uckUKgu5WdbIitoodkl2kXQ7RWI=">
+      <file path="sfinae.cpp" line="10"/>
+      <return>
+        <type name="int"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <doc>
+        <para>
+          <text>Enabling a specified return type</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <namespace name="B" id="kPgq2AM8TvyGDGm5jEWfqYlOPmY=">
+    <struct name="C" id="r/5vKTgl4cXSK5TnuZ/+P7qmkJ0=">
+      <file path="sfinae.cpp" line="15" class="def"/>
+    </struct>
+  </namespace>
+  <template>
+    <tparam name="T" class="type"/>
+    <function name="f3" id="HIZ4NeNKvHJFhj0tJIjpjaLL30U=">
+      <file path="sfinae.cpp" line="19"/>
+      <return>
+        <type id="r/5vKTgl4cXSK5TnuZ/+P7qmkJ0=" name="B::C"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <doc>
+        <para>
+          <text>Enabling a specified return type in another namespace</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <function name="f4" id="45LJB0/nCsN3KRlVtnRqNrJG818=">
+      <file path="sfinae.cpp" line="24"/>
+      <return>
+        <type name="T"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via return type with std::enable_if</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <tparam class="non-type" type="bool" default="true"/>
+    <function name="f5" id="a+UWurTVrgCdwaj2WmRbGzoFaPE=">
+      <file path="sfinae.cpp" line="29"/>
+      <return>
+        <type name="T"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via a non-type template parameter with helper</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <tparam class="non-type" type="bool" default="true"/>
+    <function name="f6" id="/yE6fwRwAIxETBjA2qovg6HKvcI=">
+      <file path="sfinae.cpp" line="34"/>
+      <return>
+        <type name="T"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via a non-type template parameter without helper</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <tparam class="non-type" type="int" default="0"/>
+    <function name="f7" id="yvozC1ZfCOoeBsvYrNKSBY1/EYg=">
+      <file path="sfinae.cpp" line="39"/>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via a non-type template parameter using int instead of bool</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <function name="f8" id="Gf4cp25Ok5ZDmOsaPZYkV1j/6kM=">
+      <file path="sfinae.cpp" line="43"/>
+      <return>
+        <type name="T"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <param default="0">
+        <type class="pointer">
+          <pointee-type name="void"/>
+        </type>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via parameter without helper</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <function name="f9" id="nt7dkGV/+Wo4uvfBAeMzChGggJs=">
+      <file path="sfinae.cpp" line="48"/>
+      <return>
+        <type name="T"/>
+      </return>
+      <param name="value">
+        <type name="T"/>
+      </param>
+      <param default="0">
+        <type class="pointer">
+          <pointee-type name="void"/>
+        </type>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via parameter with helper</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <tparam class="type" default="void"/>
+    <function name="f10" id="n8wiRMXq5jqiYScw4e5BxcZdL+c=">
+      <file path="sfinae.cpp" line="64"/>
+      <param name="t">
+        <type class="pointer">
+          <pointee-type name="T"/>
+        </type>
+      </param>
+      <doc>
+        <para>
+          <text>Enabled via type template parameter</text>
+        </para>
+        <para>
+          <text>This pattern should not be used because the function signature is unmodified and therefore only supports one overload.</text>
+        </para>
+        <para>
+          <text>It&apos;s a common mistake is to declare two function templates that differ only in their default template arguments.</text>
+        </para>
+        <para>
+          <text>This does not work because the declarations are treated as redeclarations of the same function template (default template</text>
+          <text> arguments are not accounted for in function template equivalence).</text>
+        </para>
+      </doc>
+    </function>
+  </template>
+  <template>
+    <tparam name="T" class="type"/>
+    <tparam name="Enable" class="type" default="void"/>
+    <class name="A" id="m/JW900ik2XLYvUdA4MCuWZQd80=">
+      <file path="sfinae.cpp" line="68" class="def"/>
+      <doc>
+        <para>
+          <text>The partial specialization of A is enabled via a template parameter</text>
+        </para>
+      </doc>
+    </class>
+  </template>
+  <template class="partial" id="m/JW900ik2XLYvUdA4MCuWZQd80=">
+    <tparam name="T" class="type"/>
+    <targ class="type" type="T"/>
+    <targ class="type" type="void"/>
+    <class name="A" id="IiCxqBbybfSkEqtDiLE90hOwXD8=">
+      <file path="sfinae.cpp" line="73" class="def"/>
+      <doc>
+        <para>
+          <text>Specialization for floating point types</text>
+        </para>
+      </doc>
+    </class>
+  </template>
+</namespace>
+</mrdocs>